From 61c1f56aacf3f99c8629f7fc3d30bdcd5fffa0c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B4=AE=E7=94=9F=EF=BC=88=E5=AD=90=E8=99=9A=EF=BC=89?= <2234839456@qq.com> Date: Wed, 4 Nov 2026 19:07:23 +0800 Subject: [PATCH] =?UTF-8?q?feat(rust):=20rust-spike=20=E5=90=8E=E7=AB=AF?= =?UTF-8?q?=E8=BD=AC=E6=AD=A3=E2=80=94=E2=80=94musl=20=E9=9D=99=E6=80=81?= =?UTF-8?q?=E4=BA=8C=E8=BF=9B=E5=88=B6=202.2MB=20+=20scratch=20=E9=95=9C?= =?UTF-8?q?=E5=83=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 零依赖 TTF/OTF 子集化 + woff2 编码,Windows 兼容修复(maxp maxZones、表 checksum) - 字体 API 强缓存 max-age=86400 + ETag/304 协商兜底 - 发布链路切换 build_backend_rs,Dockerfile FROM scratch 仅含 webfont-rs + dist/ --- .dockerignore | 4 + .gitignore | 8 + Dockerfile | 12 +- package.json | 5 +- rust-spike/.gitignore | 1 + rust-spike/Cargo.lock | 46 + rust-spike/Cargo.toml | 28 + rust-spike/PORTING.md | 36 + rust-spike/font/.stats.json | 1 + rust-spike/src/cache.rs | 160 ++ rust-spike/src/cff.rs | 1976 ++++++++++++++++++++ rust-spike/src/glyph_match.rs | 460 +++++ rust-spike/src/gsub.rs | 3214 +++++++++++++++++++++++++++++++++ rust-spike/src/http.rs | 193 ++ rust-spike/src/main.rs | 650 +++++++ rust-spike/src/misc.rs | 2595 ++++++++++++++++++++++++++ rust-spike/src/ttf.rs | 2173 ++++++++++++++++++++++ rust-spike/src/woff2.rs | 1025 +++++++++++ rust-spike/verify-parity.sh | 55 + src/pages/FontList.vue | 1 + 20 files changed, 12638 insertions(+), 5 deletions(-) create mode 100644 .dockerignore create mode 100644 rust-spike/.gitignore create mode 100644 rust-spike/Cargo.lock create mode 100644 rust-spike/Cargo.toml create mode 100644 rust-spike/PORTING.md create mode 100644 rust-spike/font/.stats.json create mode 100644 rust-spike/src/cache.rs create mode 100644 rust-spike/src/cff.rs create mode 100644 rust-spike/src/glyph_match.rs create mode 100644 rust-spike/src/gsub.rs create mode 100644 rust-spike/src/http.rs create mode 100644 rust-spike/src/main.rs create mode 100644 rust-spike/src/misc.rs create mode 100644 rust-spike/src/ttf.rs create mode 100644 rust-spike/src/woff2.rs create mode 100755 rust-spike/verify-parity.sh diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..e07260c --- /dev/null +++ b/.dockerignore @@ -0,0 +1,4 @@ +# 只需要 dist/ 与 dist_backend/,其余全部排除(cargo target 116M、node_modules、字体库等不进 context) +* +!dist/ +!dist_backend/ diff --git a/.gitignore b/.gitignore index 8708421..38fb433 100644 --- a/.gitignore +++ b/.gitignore @@ -47,3 +47,11 @@ packages/leafer-x-webfont/vendor # 商业化文档仅本地保留,不入库(png 截图正常跟踪) doc/*.md + + +.zig-cache +zig-out +target-perf +# 本地工具/工作区 +.chatcode/ +rust-spike/target-perf/ diff --git a/Dockerfile b/Dockerfile index efa8880..b5e9810 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,6 +1,12 @@ +# rust 后端(musl 静态二进制)+ vite-ssg 前端静态资源,FROM scratch 无基础镜像 +# 镜像内容 = webfont-rs(约2.2MB) + dist/,构建链见 package.json release 脚本: +# pnpm build(vite-ssg → dist/) +# pnpm build_backend_rs(cargo musl 静态编译 → dist_backend/webfont-rs) FROM scratch WORKDIR /home/ -COPY dist_backend/app.lrt /home/app.lrt -COPY llrt /home/llrt +COPY dist_backend/webfont-rs /home/webfont-rs COPY dist/ /home/dist/ -CMD ["/home/llrt", "/home/app.lrt"] \ No newline at end of file +# 服务器 compose 映射 8087:8087(compose 不可改),容器内固定监听 8087 +ENV PORT=8087 +EXPOSE 8087 +CMD ["/home/webfont-rs"] diff --git a/package.json b/package.json index 01cf214..848caca 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "webfont", "private": true, - "version": "1.14.6", + "version": "1.15.0", "type": "module", "scripts": { "dev": "pnpx tsx scripts/dev-all.ts", @@ -11,11 +11,12 @@ "serve:llrt": "./llrt ./dist_backend/app.cjs", "build": "vite-ssg build", "build_backend": "pnpx tsx scripts/build-backend.ts", + "build_backend_rs": "cargo build --profile tinyfast --target x86_64-unknown-linux-musl --manifest-path rust-spike/Cargo.toml && cp rust-spike/target/x86_64-unknown-linux-musl/tinyfast/webfont-rs dist_backend/webfont-rs", "lint:font-config": "pnpx tsx scripts/lint-font-config.ts", "docker_build": "docker build -t llej0/web-font:${npm_package_version} -t llej0/web-font:latest .", "docker_push": "docker push llej0/web-font:${npm_package_version} && docker push llej0/web-font:latest", "preview": "vite preview", - "release": "pnpm build && pnpm build_backend && pnpm docker_build && pnpm docker_push" + "release": "pnpm build && pnpm build_backend_rs && pnpm docker_build && pnpm docker_push" }, "dependencies": { "@unhead/vue": "^3.4.3", diff --git a/rust-spike/.gitignore b/rust-spike/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/rust-spike/.gitignore @@ -0,0 +1 @@ +/target diff --git a/rust-spike/Cargo.lock b/rust-spike/Cargo.lock new file mode 100644 index 0000000..0db842c --- /dev/null +++ b/rust-spike/Cargo.lock @@ -0,0 +1,46 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "alloc-no-stdlib" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2fb6cfd47bf496ff64095c20eaba0c201404ee38714d4142fcfa1dc334fcc7a" + +[[package]] +name = "alloc-stdlib" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5c1865780388bfa186411ab5f247819487fc4864c6e9c3106611fa347586e1" +dependencies = [ + "alloc-no-stdlib", +] + +[[package]] +name = "brotli" +version = "9.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "627b7cfb0578f0eafce087a90fcd40add1231900b69e4d4de2d456260a4f5d81" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor", +] + +[[package]] +name = "brotli-decompressor" +version = "6.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34c6783f42c21c952ad7112b354f0ba2f10760e9decea5b1b60523d6e270faaf" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + +[[package]] +name = "webfont-rs" +version = "0.1.0" +dependencies = [ + "brotli", +] diff --git a/rust-spike/Cargo.toml b/rust-spike/Cargo.toml new file mode 100644 index 0000000..6cf798e --- /dev/null +++ b/rust-spike/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "webfont-rs" +version = "0.1.0" +edition = "2024" + +[dependencies] +brotli = "9" + +[profile.release] +opt-level = 3 +lto = "thin" +codegen-units = 1 +panic = "unwind" + +# 超小二进制发布 profile(目标 3):size 优化 + 全 LTO + 去符号。 +# panic 保持 unwind:连接线程 panic 只断当前连接(abort 会因单个畸形请求打死整个服务) +# 禁 unsafe 红线不变;brotli crate 仍限 woff2.rs +[profile.tiny] +inherits = "release" +opt-level = "z" +lto = "fat" +codegen-units = 1 +strip = "symbols" + +# 小体积但保速变体:opt=3(tiny 的 opt=z 让子集化慢 1.3 倍,速度优先) +[profile.tinyfast] +inherits = "tiny" +opt-level = 3 diff --git a/rust-spike/PORTING.md b/rust-spike/PORTING.md new file mode 100644 index 0000000..27a32d7 --- /dev/null +++ b/rust-spike/PORTING.md @@ -0,0 +1,36 @@ +# rust-spike 移植规范(所有 Zig→Rust 对译代理必读) + +## 使命 +把 `zig-spike/src/*.zig` 逐模块对译为 `rust-spike/src/*.rs`。zig-spike 是 TS 后端子集化引擎的**已验证镜像**(280 用例对拍 🟢),语义疑问一律以对应 .zig 源码为准,**不要去读 backend/ TS 源码重新推导**。 + +## 字节级等价是验收标准 +相同输入下,Rust 版输出必须与 Zig 版逐字节相同(差异须能解释并经确认)。Zig 版已含全部修复(locaRange u16 溢出、P1 锚定注入、P4 hinting 剥离、P6 name 重建、P7 hmtx 折叠、cmap BMP format12 修复等)。 + +## 只移植自己的模块 +- 每个代理只写自己负责的一个 .rs 文件(可在 rust-spike/src/ 下建同名子目录组织子模块,如 src/gsub/) +- 不得修改:zig-spike/、backend/、rust-spike/src/main.rs、src/http.rs、src/cache.rs、其他代理的模块 +- 桩接口签名是跨模块契约,**不得更改**(需要新增能力时在最终报告里提出,由主会话协调) +- 禁止任何 git stash/reset/checkout/commit 操作 + +## Rust 编码规范(gs 全局规范) +- `///` doc 注释放 item 上方,内容从 Zig 版 `///` 直接翻译;`//` 普通注释同样翻译 +- snake_case 命名,与 Zig 对应关系肉眼可查(collectGids→collect_gids) +- 禁 `unsafe`、禁外部 crate(**例外:woff2.rs 允许 brotli crate**,选型见下) +- 整数转换:无损用 `as`/`try_from`;有损截断必须与 Zig `@intCast`/`@truncate` 语义逐一对齐并加注释 +- let it crash:不变量违反直接 panic(对齐 Zig),预期失败走 Result +- 迭代优于手写下标(字节解析游标类代码可保留下标游标,与 Zig 对译一致优先) + +## 工程约定 +- `cargo build --release` 必须零错误零警告;`cargo test --release` 全绿 +- 死代码警告:桩阶段未接线的 pub 能力用 `#[allow(dead_code)] // 原因` 标注 +- 并行代理共用同一 cargo 工程,cargo 有文件锁会自动排队,放心构建 + +## 验证层级(按你能做的做到最深处) +1. cargo 编译零警告 + 单元测试 +2. 模块级对拍(能独立测就测:如 woff2 可拿 Zig 服务产的 ttf 做 fixture,与 Zig 产的 woff2 字节比) +3. 端到端对拍由主会话在 ttf.rs 落地后统一做(HTTP 双实例字节 cmp,工具 rust-spike/verify-parity.sh) + +## Zig 模块语义备忘(前人确认,勿踩) +- gsub:collect_reachable 返回空 Vec ≠ 错误(版本不支持退 seed 序);keep 列表必须保持插入序不可排序;subsetGPOS 返回 null = 透传原始字节 +- cff:subsetCFF 返回 null = 非 CID CFF 不支持时的降级路径(透传) +- woff2:Zig 版静态链系统 libbrotli-dev(C brotli);TS 生产同样 C brotli;brotli 质量/参数以 woff2.zig 实际调用为准 diff --git a/rust-spike/font/.stats.json b/rust-spike/font/.stats.json new file mode 100644 index 0000000..6b52722 --- /dev/null +++ b/rust-spike/font/.stats.json @@ -0,0 +1 @@ +{"totalRequests":488,"subsetRequests":485,"subsetCacheHits":265,"totalChars":11097,"tempUploads":0,"offlineSubsets":0,"offlineDownloads":0} \ No newline at end of file diff --git a/rust-spike/src/cache.rs b/rust-spike/src/cache.rs new file mode 100644 index 0000000..e70f216 --- /dev/null +++ b/rust-spike/src/cache.rs @@ -0,0 +1,160 @@ +//! 进程级缓存(对译 zig-spike/src/main.zig 的 parsed_cache + subset_cache) +//! +//! - 预解析字体缓存:永不失效,get-or-parse 串行在锁内 +//! - 子集产物 LRU:按字节容量淘汰,语义对齐 TS subsetCache(LruCache evictByBytes) + +use std::collections::{HashMap, VecDeque}; +use std::sync::{Arc, Mutex}; + +use crate::ttf::Font; + +/// 子集缓存默认容量 10MB(SUBSET_CACHE_MAX_SIZE 可覆盖,语义对齐 TS) +pub const DEFAULT_SUBSET_CACHE_MAX_BYTES: usize = 10 * 1024 * 1024; + +/// 预解析字体缓存:path → 解析好的 Font(只读共享,Arc 派发) +pub struct FontCache { + map: Mutex>>, +} + +impl FontCache { + #[allow(dead_code)] // /api/stats 接入前未用 + pub fn new() -> Self { + FontCache { map: Mutex::new(HashMap::new()) } + } + + /// 命中零 IO + 零解析;未命中在锁内读文件并解析(二次检查避免重复解析,对齐 Zig getFont) + pub fn get_or_parse(&self, path: &str) -> Result, FontCacheError> { + let mut map = self.map.lock().unwrap(); + if let Some(f) = map.get(path) { + return Ok(f.clone()); + } + let data = std::fs::read(path).map_err(|_| FontCacheError::NotFound)?; + if data.len() > 100 * 1024 * 1024 { + return Err(FontCacheError::NotFound); + } + let font = Arc::new(Font::parse(data).map_err(|_| FontCacheError::ParseFailed)?); + map.insert(path.to_string(), font); + Ok(map.get(path).unwrap().clone()) + } + + /// 条目数(/api/stats 的 fontBufferCacheEntries 同位字段,口径注释见 Zig 版) + #[allow(dead_code)] // /api/stats 接入前未用 + pub fn len(&self) -> usize { + self.map.lock().unwrap().len() + } +} + +#[derive(Debug)] +pub enum FontCacheError { + /// 文件缺失 / 超过 100MB 上限(对外同 404) + NotFound, + /// 解析失败(对外 422) + ParseFailed, +} + +/// LRU(按字节容量):读命中移到最新端;插入超容量从最旧端淘汰。 +/// 值存 `Arc<[u8]>`——命中返回 Arc 快照,淘汰不影响正在写出的响应 +/// (语义等价 Zig 版「HIT 响应期间持锁」,锁粒度更小)。 +/// 顺序表用 VecDeque(条目量级 ~200,O(n) 触碰移动可忽略),对齐 scLookup 的 unlink+append。 +pub struct SubsetCache { + inner: Mutex, +} + +struct SubsetCacheInner { + map: HashMap>, + /// 键的访问序:front = 最旧,back = 最新 + order: VecDeque, + used_bytes: usize, + max_bytes: usize, +} + +impl SubsetCache { + pub fn new(max_bytes: usize) -> Self { + SubsetCache { + inner: Mutex::new(SubsetCacheInner { + map: HashMap::new(), + order: VecDeque::new(), + used_bytes: 0, + max_bytes, + }), + } + } + + /// 查询:命中把键移到最新端并返回 Arc 快照 + pub fn get(&self, key: &str) -> Option> { + let mut g = self.inner.lock().unwrap(); + if !g.map.contains_key(key) { + return None; + } + Self::touch(&mut g, key); + g.map.get(key).cloned() + } + + /// 插入:覆盖同键旧值;超容量从最旧端淘汰 + pub fn insert(&self, key: &str, bytes: Vec) { + let mut g = self.inner.lock().unwrap(); + let bytes: Arc<[u8]> = bytes.into(); + if let Some(old) = g.map.insert(key.to_string(), bytes) { + g.used_bytes -= old.len(); + } else { + g.order.push_back(key.to_string()); + } + g.used_bytes += g.map.get(key).unwrap().len(); + while g.used_bytes > g.max_bytes { + let Some(oldest) = g.order.pop_front() else { break }; + if let Some(v) = g.map.remove(&oldest) { + g.used_bytes -= v.len(); + } + } + } + + /// 把键移到最新端(命中语义) + fn touch(g: &mut SubsetCacheInner, key: &str) { + if let Some(pos) = g.order.iter().position(|k| k == key) { + g.order.remove(pos); + g.order.push_back(key.to_string()); + } + } + + #[allow(dead_code)] // /api/stats 接入前未用 + /// 条目数(/api/stats 的 subsetCacheEntries) + pub fn len(&self) -> usize { + self.inner.lock().unwrap().map.len() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn lru_evicts_by_bytes() { + let c = SubsetCache::new(100); + c.insert("a", vec![0u8; 60]); + c.insert("b", vec![0u8; 30]); + assert_eq!(c.len(), 2); + c.insert("c", vec![0u8; 20]); // 90 → 110 > 100,淘汰 a + assert_eq!(c.len(), 2); + assert!(c.get("a").is_none()); + assert!(c.get("b").is_some() && c.get("c").is_some()); + } + + #[test] + fn lru_touch_prevents_eviction() { + let c = SubsetCache::new(100); + c.insert("a", vec![0u8; 60]); + c.insert("b", vec![0u8; 30]); + c.get("a"); // a 变最新,b 最旧 + c.insert("c", vec![0u8; 20]); // 淘汰 b + assert!(c.get("a").is_some() && c.get("b").is_none()); + } + + #[test] + fn insert_over_same_key_replaces_bytes() { + let c = SubsetCache::new(100); + c.insert("k", vec![0u8; 80]); + c.insert("k", vec![0u8; 10]); // 覆盖,不新增顺序位 + assert_eq!(c.len(), 1); + assert_eq!(c.get("k").unwrap().len(), 10); + } +} diff --git a/rust-spike/src/cff.rs b/rust-spike/src/cff.rs new file mode 100644 index 0000000..30c7c93 --- /dev/null +++ b/rust-spike/src/cff.rs @@ -0,0 +1,1976 @@ +//! CFF 表子集化(自 backend/font_util/cff-subset.ts 语义移植)+ 非 CID(name-keyed 单 Private)路径扩展 +//! (对译 zig-spike/src/cff.zig) +//! +//! 移植语义说明: +//! - CID-keyed 路径逐段对应 TS subsetCFF:charset 格式0 重建、FDSelect 按需查询 + 格式0/3 重编码、 +//! FDArray/Top DICT/Private DICT op19 偏移联合迭代收敛、Local Subr 引用闭包 + 重映射 + bias 重算。 +//! - 关键语义(历史验证的坑):Local Subr 的 callsubr operand 是「subr 编号 + bias」的相对值, +//! subr 子集化重编号后每个 callsubr operand 必须重算(rewrite_charstring 截断重写),不可透传原字节; +//! Global Subr 不子集化,callgsubr operand 原样保留(bias 不变)。 +//! - stemGains:OTS 的 num_stems 跨 callsubr 共享,hintmask/cntrmask 掩码字节数 = (stems+7)/8, +//! 重写时遇 callsubr 必须累加被调 subr 的递归 stem 净增量,否则掩码字节被误读。 +//! 引用收集阶段(collectSubrRefs/convergeRefs)与 TS 一致不传 stemGains(收集期掩码偏移 +//! 误差不影响引用集正确性,仅重写期需要精确)。 +//! - 非 CID 路径(TS 遇到返回 null 降级,本实现补齐):单 Private DICT 挂在 Top DICT(op 18), +//! 无 FDArray/FDSelect;charset 语义是 SID(缺省 op 时按 ISOAdobe 隐式 charset:编号=gid); +//! Encoding 表(op 16)从 Top DICT 删除(子集后其内部 glyph 索引已失效,浏览器消费 cmap 不消费它)。 +//! - stripHints/charstringStackOverflows(OTS operand 栈深 >48 时剥 hint)逐字节对应 TS 行为, +//! 包括其 callsubr/callgsubr 操作符丢弃、操作数保留的既有语义。 +//! - Zig 版用请求级 arena 分配器统一释放;Rust 版所有权即生命周期,无对应物。 +#![allow(dead_code)] // subset_cff 未接线(ttf.rs 移植后调用),落地后移除 + +use std::collections::HashMap; +use std::collections::HashSet; +use std::collections::hash_map::Entry; + +/// UnsupportedCff:结构超出支持范围(缺 CharStrings/FDArray 等),调用方降级。 +/// (Zig CffError 另有 OutOfMemory;Rust 侧分配失败直接 abort,无对应成员) +#[derive(Debug)] +pub enum CffError { + UnsupportedCff, +} + +// --------------------------------------------------------------------------- +// 常量 +// --------------------------------------------------------------------------- + +/// Top DICT 操作码(双字节 12,n 存为 (12<<8)|n) +const OP_CHARSET: u32 = 15; +const OP_ENCODING: u32 = 16; +const OP_CHARSTRINGS: u32 = 17; +const OP_PRIVATE: u32 = 18; +/// Private DICT 内:Local Subr INDEX 相对 Private DICT 起始的偏移 +const OP_LOCAL_SUBR: u32 = 19; +const OP_FD_ARRAY: u32 = (12 << 8) | 36; +const OP_FD_SELECT: u32 = (12 << 8) | 37; +const OP_ROS: u32 = (12 << 8) | 30; + +/// Type 2 charstring 操作码(Adobe Type 2 Charstring Format) +const T2_CALLSUBR: u8 = 10; +const T2_ENDCHAR: u8 = 14; +const T2_HSTEM: u8 = 1; +const T2_VSTEM: u8 = 3; +const T2_HSTEMHM: u8 = 18; +const T2_VSTEMHM: u8 = 23; +const T2_HINTMASK: u8 = 19; +const T2_CNTRMASK: u8 = 20; +const T2_CALLGSUBR: u8 = 29; + +/// OTS(Chrome 字体安全校验)允许的最大 operand 栈深;超限字形须 stripHints 剥 hint 区 +const T2_MAX_STACK: usize = 48; + +/// 无 Private 池的标记值(Private offset 不可能取到) +const NO_PRIV: usize = usize::MAX; + +// --------------------------------------------------------------------------- +// 基础读取工具(越界按 0 处理,仅损坏表触达;合法字体两者一致) +// --------------------------------------------------------------------------- + +/// 带边界检查的 u8 读取 +fn u8_at(b: &[u8], off: usize) -> u8 { + if off >= b.len() { + return 0; + } + b[off] +} + +/// 带边界检查的 u16 大端读取 +fn u16_at(b: &[u8], off: usize) -> u16 { + if off + 2 > b.len() { + return 0; + } + ((b[off] as u16) << 8) | b[off + 1] as u16 +} + +/// 带边界检查的 u32 大端读取 +fn u32_at(b: &[u8], off: usize) -> u32 { + if off + 4 > b.len() { + return 0; + } + ((b[off] as u32) << 24) | (b[off + 1] as u32) << 16 | (b[off + 2] as u32) << 8 | b[off + 3] as u32 +} + +/// 带 i16 符号的 int16 大端读取 +fn i16_at(b: &[u8], off: usize) -> i16 { + u16_at(b, off) as i16 +} + +// --------------------------------------------------------------------------- +// CFF INDEX 结构 +// --------------------------------------------------------------------------- + +/// INDEX 轻量头部:只解析 count/offSize/dataStart/end,不展开 (count+1) 个偏移量数组 +/// (思源 Local Subr INDEX 可达 26550 subr,全量展开占 subsetCFF 一半耗时,按需读单个 offset) +#[derive(Clone, Copy)] +struct IndexHeader { + /// INDEX 起始偏移 + start: usize, + /// INDEX 内对象数量 + count: usize, + /// 偏移量字节宽度(1~4) + off_size: u8, + /// 偏移量数组起始(紧接 count/offSize 头;count=0 时无效) + off_base: usize, + /// 数据区起始(紧接偏移量数组之后) + data_start: usize, + /// INDEX 结束位置(最后一个对象尾,不含) + end: usize, +} + +/// 只读 INDEX 头部。offset 是 1-based:object i 的数据区间 = [data_start + off(i) - 1, data_start + off(i+1) - 1) +fn read_index_header(b: &[u8], pos: usize) -> IndexHeader { + let count = u16_at(b, pos) as usize; + if count == 0 { + return IndexHeader { start: pos, count: 0, off_size: 0, off_base: pos + 2, data_start: pos + 2, end: pos + 2 }; + } + let off_size = u8_at(b, pos + 2); + let off_base = pos + 3; + let data_start = off_base + (count + 1) * off_size as usize; + let last_off = index_offset_at(b, off_base, off_size, count); + IndexHeader { start: pos, count, off_size, off_base, data_start, end: data_start + last_off as usize - 1 } +} + +/// 读 INDEX 第 i 个偏移量(1-based 大端 off_size 字节) +fn index_offset_at(b: &[u8], off_base: usize, off_size: u8, i: usize) -> u32 { + let mut v: u32 = 0; + let mut p = off_base + i * off_size as usize; + for _ in 0..off_size { + v = (v << 8) | u8_at(b, p) as u32; + p += 1; + } + v +} + +/// 全量 INDEX(含偏移量数组展开),仅用于小 INDEX(Top DICT INDEX / FDArray INDEX) +struct FullIndex { + count: usize, + /// (count+1) 个 1-based 偏移量 + offsets: Vec, + data_start: usize, + /// INDEX 结束位置(= data_start + offsets[count] - 1) + end: usize, +} + +fn read_index_full(b: &[u8], pos: usize) -> FullIndex { + let hdr = read_index_header(b, pos); + let mut offsets = Vec::with_capacity(hdr.count + 1); + for i in 0..=hdr.count { + offsets.push(index_offset_at(b, hdr.off_base, hdr.off_size, i)); + } + FullIndex { count: hdr.count, offsets, data_start: hdr.data_start, end: hdr.end } +} + +// --------------------------------------------------------------------------- +// CFF DICT 解析/编码 +// --------------------------------------------------------------------------- + +/// 解析 CFF DICT 字节为 操作码 → 操作数数组 的映射(语义对齐 TS Map:同操作码后者覆盖前者)。 +/// 操作数编码(CFF 规范 §3.1):28=int16、29=int32、32~246 单字节、247~250/251~254 双字节、 +/// 30=BCD 实数(完整跳过,否则 BCD 内 <=21 字节被误判为操作码致边界错乱)。 +fn parse_dict(b: &[u8], start: usize, end: usize) -> HashMap> { + let mut dict: HashMap> = HashMap::new(); + let mut operands: Vec = Vec::new(); + let mut p = start; + let clamped_end = end.min(b.len()); + while p < clamped_end { + let b0 = b[p]; + p += 1; + if b0 <= 21 { + let op: u32 = if b0 == 12 { + let o = (12u32 << 8) | u8_at(b, p) as u32; + p += 1; + o + } else { + b0 as u32 + }; + dict.insert(op, operands.clone()); + operands.clear(); + } else if b0 == 28 { + operands.push(i16_at(b, p) as i32); + p += 2; + } else if b0 == 29 { + operands.push(u32_at(b, p) as i32); + p += 4; + } else if b0 == 30 { + // BCD 实数:每字节两 nibble,任一 nibble 为 0xf 结束 + while p < clamped_end { + let byte = b[p]; + p += 1; + if (byte >> 4) == 0xf || (byte & 0xf) == 0xf { + break; + } + } + } else if (32..=246).contains(&b0) { + operands.push(b0 as i32 - 139); + } else if (247..=250).contains(&b0) { + operands.push((b0 as i32 - 247) * 256 + u8_at(b, p) as i32 + 108); + p += 1; + } else if (251..=254).contains(&b0) { + operands.push(-(b0 as i32 - 251) * 256 - u8_at(b, p) as i32 - 108); + p += 1; + } + } + dict +} + +// --------------------------------------------------------------------------- +// 字节写入器 +// --------------------------------------------------------------------------- + +/// 大端序字节写入器(对应 TS combineBytes/writeIndex/Uint8Array 写指针模式) +struct W { + buf: Vec, +} + +impl W { + fn new() -> W { + W { buf: Vec::new() } + } + + fn w8(&mut self, v: u8) { + self.buf.push(v); + } + + fn w16(&mut self, v: u16) { + self.buf.push((v >> 8) as u8); + self.buf.push((v & 0xff) as u8); + } + + /// 编码一个 DICT 整数操作数(CFF 规范 §3.1 整数编码,选最短形式) + fn dict_int(&mut self, v: i32) { + if v >= -107 && v <= 107 { + self.w8((v + 139) as u8); + } else if v >= 108 && v <= 1131 { + let v0 = (v - 108) as u32; + self.w8((247 + (v0 >> 8)) as u8); + self.w8((v0 & 0xff) as u8); + } else if v >= -1131 && v <= -108 { + let v0 = (-v - 108) as u32; + self.w8((251 + (v0 >> 8)) as u8); + self.w8((v0 & 0xff) as u8); + } else if v >= -32768 && v <= 32767 { + self.w8(28); + self.w16(v as i16 as u16); + } else { + self.w8(29); + self.w32(v as u32); + } + } + + fn w32(&mut self, v: u32) { + self.buf.push(((v >> 24) & 0xff) as u8); + self.buf.push(((v >> 16) & 0xff) as u8); + self.buf.push(((v >> 8) & 0xff) as u8); + self.buf.push((v & 0xff) as u8); + } + + fn w_bytes(&mut self, s: &[u8]) { + self.buf.extend_from_slice(s); + } +} + +/// 拼接多个字节切片 +fn combine(parts: &[&[u8]]) -> Vec { + let total: usize = parts.iter().map(|p| p.len()).sum(); + let mut out = Vec::with_capacity(total); + for p in parts { + out.extend_from_slice(p); + } + out +} + +/// 计算 subr INDEX 的 bias(CFF 规范:调用编号 = 实际 subr 索引 + bias) +fn subr_bias(n_subrs: usize) -> i32 { + if n_subrs < 1240 { + 107 + } else if n_subrs < 33900 { + 1131 + } else { + 32768 + } +} + +// --------------------------------------------------------------------------- +// Type 2 charstring 扫描 / 重写 / 剥离 +// --------------------------------------------------------------------------- + +// --------------------------------------------------------------------------- +// 执行级 charstring 模拟(跨 callsubr 边界共享栈的 stem 精确追踪) +// --------------------------------------------------------------------------- + +/// 执行级模拟上下文:原 Local Subr INDEX 与 Global Subr INDEX(均指原字体字节流)。 +/// 模拟、重写、剥 hint 三条路径共用同一执行语义,保证掩码字节数与读取方(OTS/FreeType)一致。 +#[derive(Clone, Copy)] +struct SimCtx { + /// 原 Local Subr INDEX(无 Private 时 count=0) + idx: IndexHeader, + /// 原 local subr bias + local_bias: i32, + gsubr_hdr: IndexHeader, + gsubr_bias: i32, +} + +impl SimCtx { + /// 无 Private 时的占位上下文(callsubr 必越界 → 模拟按不可分析处理) + fn empty(gsubr_hdr: IndexHeader) -> SimCtx { + let empty_idx = IndexHeader { start: 0, count: 0, off_size: 0, off_base: 2, data_start: 2, end: 2 }; + SimCtx { idx: empty_idx, local_bias: 0, gsubr_hdr, gsubr_bias: subr_bias(gsubr_hdr.count) } + } +} + +/// 预模拟记录:subr 的进入/返回时刻精确状态(stems 与栈深跨 callsubr 边界共享)。 +/// rewrite/strip_hints 的 callsubr 查此表 O(1) 推进,免去逐次递归展开被调 body。 +/// 不同调用点返回状态不一致(或流不可分析)时 consistent=false,该池降级透传。 +struct EntryRec { + /// sn → 进入 body 时的 num_stems(body 内掩码宽度 = 进入 stems + body 内声明数) + map: HashMap, + /// sn → 返回时的 num_stems(调用方 stem_count 增量 = exit - entry,数值精确) + exit_stems: HashMap, + /// sn → 返回时的栈深(==0 时调用方查表直接清栈;>0 需真实栈值,走递归模拟保底) + exit_len: HashMap, + /// gsn → (stems 增量, 返回时栈深)。gsubr 不重写字节,仅需执行效应; + /// 增量而非累计值:gsubr 调用点的累计 stems 天然不同,增量一致即可查表 + gsubr_exit: HashMap, + consistent: bool, + /// entry 不一致的 subr 内是否出现「掩码字节宽度跨调用点不一致」的 hintmask/cntrmask。 + /// 合法性判据是掩码宽度而非 entry stems:同一 body 字节流只写一份掩码,FreeType/OTS + /// 按执行点 (stems+7)>>3 跳宽,浏览器渲染正常的字体各调用点跳宽必然等于物理宽度; + /// stems 数不同但落在同一宽度桶(如 13/14 均 2 字节)时 body 仍可安全重写 + /// (rewrite 按首记录 stems 推进跳宽 = 物理宽度 = 各执行点宽度) + bad_mask: bool, + /// (gid, mask op 绝对位置) → 掩码字节数(cs 顶层帧记录;rewrite 语法扫描跳宽查表) + cs_masks: HashMap<(u32, u32), u16>, + /// (旧 sn, mask op 绝对位置) → 掩码字节数(local subr 帧记录;conflicted subr 各调用点 + /// 宽度桶一致(校验过)故值唯一) + sn_masks: HashMap<(u32, u32), u16>, + /// 执行路径上真实调用的 local subr 编号(执行级闭包,含嵌套)。 + /// 语法扫描(collect_subr_refs)的 hintmask 跳宽是静态 stems 推算,callsubr body 内 + /// 声明 hints 时后续 mask 跳宽错位 → 扫描错位漏收集 callsubr(思源 Light 实测命中); + /// 执行级收集与路径精确一致,两者取并集 + refs: HashSet, +} + +/// 模拟帧信息(掩码宽度记录归因:cs 顶层帧入 cs_masks;local subr 帧入 sn_masks 并校验 +/// conflicted subr 的宽度桶一致性;gsubr 帧透传不重写、掩码字节原样保留,无宽度依赖, +/// callgsubr 递归传 FRAME_GSUBR 不记录;gsubr 帧内 callsubr 触发池级透传) +#[derive(Clone, Copy)] +struct Frame { + sn: u32, + conflicted: bool, + is_cs: bool, + /// gsubr 体内帧(callsubr 在此帧执行 = gsubr_calls_local,禁用本池重编号) + is_gsubr: bool, +} + +const FRAME_NOT_SUBR: Frame = Frame { sn: u32::MAX, conflicted: false, is_cs: false, is_gsubr: false }; +const FRAME_GSUBR: Frame = Frame { sn: u32::MAX, conflicted: false, is_cs: false, is_gsubr: true }; + +/// 模拟运行状态(模拟器与递归帧共享) +struct SimState<'a> { + sim: &'a SimCtx, + /// 峰值 operand 栈深是否超 T2_MAX_STACK(OTS 拒收阈值,触发 strip hint 路径) + overflow: bool, + /// 预模拟 entry 记录(仅 analyze_entry_stems 传入) + rec: Option<&'a mut EntryRec>, + /// 执行路径上「gsubr 体内 callsubr」:本池 local subr 不可重编号(透传 gsubr 的 + /// operand 仍指旧编号),整池降级透传。执行级判定替代 gsubr INDEX 全扫 + gsubr_calls_local: bool, + /// cs 顶层帧是否执行过 callsubr(仅 analyze_entry_stems 逐字形传入标志用; + /// 执行级判定比语法扫描精确——错位扫描会把坐标误判成 callsubr) + top_has_subr: bool, +} + +/// escape 算术/逻辑操作符的栈效应(对译 OTS:pop arity 个、压回 None 占位)。 +/// None 占位与 255 fixed 编码一致:作 callsubr 操作数时模拟按不可分析处理(OTS 同样拒收)。 +fn escape_stack_effect(b1: u8, stack: &mut Vec>) { + match b1 { + 18 => { + stack.pop(); // drop + } + 27 => stack.push(None), // dup + 28 => { + stack.pop(); + stack.pop(); + stack.push(None); + stack.push(None); // exch + } + // 二元算术/逻辑:and or div add sub eq ne lt le gt ge + 3 | 4 | 5 | 10 | 11 | 12 | 24 | 22 => { + stack.pop(); + stack.pop(); + stack.push(None); + } + // 一元:abs neg rsqrt 等 + 9 | 14 | 15 => { + stack.pop(); + stack.push(None); + } + // 其余 escape(绘图族/保留)消费全部 operand + _ => stack.clear(), + } +} + +/// 执行级模拟一段 Type 2 charstring/subr body(直线执行,无控制流)。 +/// OTS 的 operand 栈与 num_stems 跨 callsubr 边界共享——「subr 消费调用方压栈操作数」 +/// 模式(思源 Bold subr5572:9 字节 body 仅一条空栈 hstem,11 个操作数全部来自调用方) +/// 静态线性扫描原理上无法计数,必须在真栈上执行。掩码字节按执行期 num_stems 跳过。 +/// 返回 false = 流不可分析(假 callsubr/越界/gsubr 体内 callsubr/未定义操作符), +/// 调用方(该池)降级透传路径。 +#[allow(clippy::too_many_arguments)] +fn sim_exec( + b: &[u8], + start: usize, + end: usize, + st: &mut SimState, + stack: &mut Vec>, + stems: &mut usize, + depth: usize, + // 当前帧所属 subr(掩码宽度归因,见 Frame 注释) + frame: Frame, +) -> bool { + if depth > 64 { + return false; + } + let clamped_end = end.min(b.len()); + let mut p = start; + while p < clamped_end { + let b0 = b[p]; + p += 1; + if b0 >= 32 { + if b0 <= 246 { + stack.push(Some(b0 as i32 - 139)); + } else if b0 == 255 { + stack.push(None); + p += 4; + } else if b0 <= 250 { + stack.push(Some((b0 as i32 - 247) * 256 + u8_at(b, p) as i32 + 108)); + p += 1; + } else { + stack.push(Some(-(b0 as i32 - 251) * 256 - u8_at(b, p) as i32 - 108)); + p += 1; + } + if stack.len() > T2_MAX_STACK { + st.overflow = true; + } + } else if b0 == 28 { + stack.push(Some(i16_at(b, p) as i32)); + p += 2; + if stack.len() > T2_MAX_STACK { + st.overflow = true; + } + } else if b0 == 12 { + escape_stack_effect(u8_at(b, p), stack); + p += 1; + } else if b0 == T2_HSTEM || b0 == T2_VSTEM || b0 == T2_HSTEMHM || b0 == T2_VSTEMHM { + *stems += stack.len() >> 1; + stack.clear(); + } else if b0 == T2_HINTMASK || b0 == T2_CNTRMASK { + // hintmask 栈上操作数是 vstem 声明(奇数含 width 时 ss>>1 恰为去 width 后的 stems 数) + *stems += stack.len() >> 1; + let skip = ((*stems + 7) >> 3) as u16; + let op_pos = (p - 1) as u32; + if let Some(rec) = st.rec.as_deref_mut() { + if frame.is_cs { + // cs 顶层帧:每 (gid, pos) 至多一次,直接记录 + rec.cs_masks.insert((frame.sn, op_pos), skip); + } else if !frame.is_gsubr { + // local subr 帧:校验各调用点掩码宽度桶一致(一致 = 物理宽度唯一,可重写) + // gsubr 帧不记录:body 不重写、掩码原样拷贝,宽度信息无消费者 + let key = (frame.sn, op_pos); + match rec.sn_masks.get(&key) { + None => { + rec.sn_masks.insert(key, skip); + } + Some(&prev) => { + if prev != skip { + rec.bad_mask = true; + } + } + } + } + } + p += skip as usize; + if p > clamped_end { + return false; + } + stack.clear(); + } else if b0 == T2_CALLSUBR { + // cs 顶层帧的 callsubr:标记该字形含直接 subr 调用(重写路径判定用) + if frame.is_cs { + st.top_has_subr = true; + } + // gsubr 体内 callsubr:透传的 gsubr operand 无法重写 → 本池禁重编号 + if frame.is_gsubr { + st.gsubr_calls_local = true; + } + // 操作数可能在栈上(跨边界),栈顶即调用编号 + let top = stack.pop().flatten(); + let Some(sn_v) = top else { return false }; + let sn = sn_v + st.sim.local_bias; + if sn < 0 { + return false; + } + let snu = sn as usize; + if snu >= st.sim.idx.count { + return false; + } + // entry 不一致仅保留首记录(rewrite 的 stem_base/跳宽按首记录 = 物理宽度), + // 冲突是否致命由该 body 内 mask 的宽度桶校验决定(bad_mask) + let mut conflicted = false; + if let Some(rec) = st.rec.as_deref_mut() { + let e = rec.map.entry(snu as u32).or_insert(*stems); + if *e != *stems { + conflicted = true; + } + // 执行路径真实可达 subr(嵌套经递归自然覆盖,无需 fixpoint 迭代) + rec.refs.insert(snu as u32); + } + let ss = st.sim.idx.data_start + + index_offset_at(b, st.sim.idx.off_base, st.sim.idx.off_size, snu) as usize + - 1; + let se = st.sim.idx.data_start + + index_offset_at(b, st.sim.idx.off_base, st.sim.idx.off_size, snu + 1) as usize + - 1; + // 被调 body 帧继承 is_gsubr:gsubr → subr → subr 链路全程在透传域内 + if !sim_exec(b, ss, se, st, stack, stems, depth + 1, Frame { sn: snu as u32, conflicted, is_cs: false, is_gsubr: frame.is_gsubr }) { + return false; + } + // 被调 body 返回后的效应(stems 累计/栈深)若跨调用点唯一则记入快路径表; + // 不唯一(如 callee 留操作数给 caller 且数量依调用点而变)时写哨兵值淘汰出 + // 快路径,rewrite 对该 sn 递归模拟保底(递归对任意调用点均精确),不降级整池 + if let Some(rec) = st.rec.as_deref_mut() { + let e = rec.exit_stems.entry(snu as u32).or_insert(*stems); + if *e != *stems { + *e = usize::MAX; + } + let l = rec.exit_len.entry(snu as u32).or_insert(stack.len()); + if *l != stack.len() { + *l = usize::MAX; + } + } + } else if b0 == T2_CALLGSUBR { + let top = stack.pop().flatten(); + let Some(gn_v) = top else { return false }; + let gn = gn_v + st.sim.gsubr_bias; + if gn < 0 { + return false; + } + let gnu = gn as usize; + if gnu >= st.sim.gsubr_hdr.count { + return false; + } + let ss = st.sim.gsubr_hdr.data_start + + index_offset_at(b, st.sim.gsubr_hdr.off_base, st.sim.gsubr_hdr.off_size, gnu) as usize + - 1; + let se = st.sim.gsubr_hdr.data_start + + index_offset_at(b, st.sim.gsubr_hdr.off_base, st.sim.gsubr_hdr.off_size, gnu + 1) as usize + - 1; + // gsubr 不重写字节,仅记录执行效应供 rewrite/strip 查表推进。 + // 记录 stems 增量(非累计值):gsubr 在不同字形/嵌套深度的调用点累计天然不同, + // 只要增量与返回栈深一致即可查表 + let entry_stems_at_call = *stems; + if !sim_exec(b, ss, se, st, stack, stems, depth + 1, FRAME_GSUBR) { + return false; + } + let delta = *stems - entry_stems_at_call; + if let Some(rec) = st.rec.as_deref_mut() { + let e = rec.gsubr_exit.entry(gnu as u32).or_insert((delta, stack.len())); + if *e != (delta, stack.len()) { + // 效应不唯一:哨兵淘汰出快路径,rewrite 递归模拟保底 + *e = (usize::MAX, usize::MAX); + } + } + } else if b0 == T2_ENDCHAR || b0 == 11 { + // endchar/return:终止当前帧(endchar 经递归逐层传播终止) + return true; + } else if matches!(b0, 15 | 16 | 21 | 22 | 4 | 5 | 6 | 7 | 8 | 24 | 25 | 26 | 27 | 30 | 31) { + // 绘图/flex 操作符消费全部 operand;15/16(vsindex/blend) OTS 在 CFF1 直接拒 + if matches!(b0, 15 | 16) { + return false; + } + stack.clear(); + } else { + // 未定义操作符:OTS 直接拒收,按不可分析处理 + return false; + } + } + // 字节耗尽(subr body 隐式 return;顶层宽容——合法性由下游 OTS 校验兜底) + true +} + +/// 对引用闭包内全部子集 charstring 做执行级预模拟: +/// 1. 记录每个 subr 进入时的 num_stems(callsubr 编号重写与掩码跳宽推进用) +/// 2. 记录 cs 顶层帧与 local subr 帧各 hintmask 的物理掩码字节数(rewrite 语法扫描跳宽查表) +/// 3. 校验 conflicted subr 的掩码宽度桶跨调用点一致(不一致 → bad_mask → 整池降级透传) +/// 4. per-gid operand 栈深超限标志(执行级真栈峰值,分发期免二次模拟) +/// 5. per-gid cs 顶层 callsubr 标志(执行级精确判定,分发期 rewrite 路径用) +/// 任一 charstring 不可分析(病态流/callsubr 栈顶非字面量)→ consistent=false → 该池降级透传。 +fn analyze_entry_stems( + b: &[u8], + gids: &[usize], + cs_ranges: &[[usize; 2]], + sim: &SimCtx, +) -> (EntryRec, Vec, Vec, bool) { + let mut rec = EntryRec { + map: HashMap::new(), + exit_stems: HashMap::new(), + exit_len: HashMap::new(), + gsubr_exit: HashMap::new(), + cs_masks: HashMap::new(), + sn_masks: HashMap::new(), + refs: HashSet::new(), + consistent: true, + bad_mask: false, + }; + // per-gid 栈深超限标志(执行级真栈峰值,比线性浅扫精确),分发期免二次模拟 + let mut overflow = vec![false; cs_ranges.len()]; + // per-gid cs 顶层 callsubr 标志(执行级精确判定,分发期 rewrite 路径用) + let mut has_subr = vec![false; cs_ranges.len()]; + // 本池执行路径上是否「gsubr 体内 callsubr」(禁重编号) + let mut gcl = false; + for &gi in gids { + let r = cs_ranges[gi]; + let mut stack: Vec> = Vec::new(); + let mut stems: usize = 0; + let mut st = SimState { sim, overflow: false, rec: Some(&mut rec), gsubr_calls_local: false, top_has_subr: false }; + let frame = Frame { sn: gi as u32, conflicted: false, is_cs: true, is_gsubr: false }; + if !sim_exec(b, r[0], r[1], &mut st, &mut stack, &mut stems, 0, frame) { + rec.consistent = false; + break; + } + overflow[gi] = st.overflow; + has_subr[gi] = st.top_has_subr; + gcl |= st.gsubr_calls_local; + } + (rec, overflow, has_subr, gcl) +} + +/// 检查 charstring 的 operand 峰值栈深是否超过 OTS 限制(执行级模拟)。 +/// 超限字形不可透传,必须 stripHints 剥离 hint 区。 +fn charstring_stack_overflows(b: &[u8], start: usize, end: usize, sim: &SimCtx) -> bool { + let mut stack: Vec> = Vec::new(); + let mut stems: usize = 0; + let mut st = SimState { sim, overflow: false, rec: None, gsubr_calls_local: false, top_has_subr: false }; + let _ = sim_exec(b, start, end, &mut st, &mut stack, &mut stems, 0, FRAME_NOT_SUBR); + st.overflow +} + +/// 剥离 charstring 的 hint 区(stem 声明及其 operands、hintmask/cntrmask 及其掩码字节)。 +/// 思源等源字体有字形 operand 栈深 >48(Adobe 合法但 OTS 拒收),剥 hint 后栈深必然合规。 +/// 逐字节对应 TS 行为(含 callsubr/callgsubr 操作符丢弃、操作数保留的既有语义)。 +/// 掩码字节的跳过宽度依赖执行期 num_stems(跨 callsubr 边界共享栈): +/// 有预模拟记录时查表 O(1) 推进,降级池(rec=None)递归模拟跟进。 +fn strip_hints(b: &[u8], start: usize, end: usize, sim: &SimCtx, rec: Option<&EntryRec>) -> Vec { + let clamped_end = end.min(b.len()); + let mut out: Vec = Vec::new(); + let mut p = start; + let mut stack: Vec> = Vec::new(); + let mut stems: usize = 0; + let mut st = SimState { sim, overflow: false, rec: None, gsubr_calls_local: false, top_has_subr: false }; + while p < clamped_end { + let b0 = b[p]; + p += 1; + if b0 >= 32 { + out.push(b0); + if b0 == 255 { + stack.push(None); + for _ in 0..4 { + out.push(u8_at(b, p)); + p += 1; + } + } else if b0 >= 247 { + if b0 <= 250 { + stack.push(Some((b0 as i32 - 247) * 256 + u8_at(b, p) as i32 + 108)); + } else { + stack.push(Some(-(b0 as i32 - 251) * 256 - u8_at(b, p) as i32 - 108)); + } + out.push(u8_at(b, p)); + p += 1; + } else { + stack.push(Some(b0 as i32 - 139)); + } + continue; + } + if b0 == 28 { + stack.push(Some(i16_at(b, p) as i32)); + out.push(28); + out.push(u8_at(b, p)); + out.push(u8_at(b, p + 1)); + p += 2; + continue; + } + if b0 == T2_HSTEM || b0 == T2_VSTEM || b0 == T2_HSTEMHM || b0 == T2_VSTEMHM { + // 丢弃操作码与栈上 operands:回退输出到本段 operand 起点 + out.truncate(out.len() - stack.len()); + stems += stack.len() >> 1; + stack.clear(); + continue; + } + if b0 == T2_HINTMASK || b0 == T2_CNTRMASK { + // 丢弃操作码与掩码字节;栈上 operands(若有)一并丢弃。 + // OTS/FreeType 语义:hintmask 栈上操作数是 vstem 声明(奇数含 width 时 ss>>1 恰为去 width 后的 stems 数), + // 必须计入后掩码字节数才与源编码一致,否则漏跳掩码字节致后续流失步 + out.truncate(out.len() - stack.len()); + stems += stack.len() >> 1; + p += (stems + 7) >> 3; + stack.clear(); + continue; + } + if b0 == T2_CALLSUBR || b0 == T2_CALLGSUBR { + // 操作符丢弃、操作数保留(TS 既有语义);推进 stems/栈使后续原始流掩码字节 + // 的跳过宽度与读取方一致。查表 O(1)(返回栈空时);否则递归模拟跟进; + // 跟进成功时保留返回后的栈状态(跨边界输出模式后续 stem 依赖它),未跟进才清栈 + let top = stack.pop().flatten(); + let target = top.and_then(|v| { + let hdr = if b0 == T2_CALLSUBR { sim.idx } else { sim.gsubr_hdr }; + let bias = if b0 == T2_CALLSUBR { sim.local_bias } else { sim.gsubr_bias }; + let sn = v + bias; + if sn >= 0 && (sn as usize) < hdr.count { Some(sn as usize) } else { None } + }); + // 常规快路径:预模拟记录的返回效应(栈空 → 直接赋累计 stems 并清栈) + let fast: Option<(&EntryRec, usize, usize)> = match (rec, target) { + (Some(rc), Some(tn)) => { + let el = if b0 == T2_CALLSUBR { + rc.exit_len.get(&(tn as u32)).copied() + } else { + rc.gsubr_exit.get(&(tn as u32)).map(|&e| e.1) + }; + el.map(|el| (rc, tn, el)) + } + _ => None, + }; + let mut followed = false; + if let Some((rc, tn, 0)) = fast { + if b0 == T2_CALLSUBR { + stems = rc.exit_stems[&(tn as u32)]; + } else { + stems += rc.gsubr_exit[&(tn as u32)].0; + } + stack.clear(); + followed = true; + } else if let Some(tn) = target { + let hdr = if b0 == T2_CALLSUBR { sim.idx } else { sim.gsubr_hdr }; + let ss = hdr.data_start + index_offset_at(b, hdr.off_base, hdr.off_size, tn) as usize - 1; + let se = hdr.data_start + index_offset_at(b, hdr.off_base, hdr.off_size, tn + 1) as usize - 1; + if sim_exec(b, ss, se, &mut st, &mut stack, &mut stems, 1, FRAME_NOT_SUBR) { + followed = true; + } + } + if !followed { + stack.clear(); + } + continue; + } + if b0 == 12 { + out.push(12); + out.push(u8_at(b, p)); + escape_stack_effect(u8_at(b, p), &mut stack); + p += 1; + continue; + } + out.push(b0); + if b0 == T2_ENDCHAR { + break; + } + stack.clear(); + } + out +} + +/// 在升序 remap 表中二分查找旧 subr 编号,返回新编号(未保留返回 None) +fn remap_lookup(sorted_refs: &[u32], old_sn: u32) -> Option { + let mut lo: usize = 0; + let mut hi: usize = sorted_refs.len(); + while lo < hi { + let mid = (lo + hi) / 2; + if sorted_refs[mid] < old_sn { + lo = mid + 1; + } else { + hi = mid; + } + } + if lo < sorted_refs.len() && sorted_refs[lo] == old_sn { + return Some(lo as u32); + } + None +} + +/// 重写 Type 2 charstring/subr(语法级):把 callsubr 的调用编号 operand 重映射到子集编号 +/// (减新 bias),掩码字节与其余内容原样拷贝。global subr 不子集化(callgsubr operand 原样, +/// bias 不变)。 +/// 正确性基础(由 analyze_entry_stems→sim_exec 预模拟保证,否则池已降级透传): +/// 1. callsubr/callgsubr 栈顶必为紧邻字面量(算术/dup/drop 中间操作 → 栈顶非字面量 → 池降级), +/// 故 operand 取「最近一次入栈的源流字面量」即可,无需执行栈推进 +/// 2. rewrite 只改 callsubr 编号,字形执行点 stems 序列不变 → 掩码物理宽度不变, +/// 跳宽查预模拟记录表 masks(key=(帧键, mask op 绝对位置);帧键 cs=gid、subr=旧 sn) +/// 返回 None:语法扫描遇预模拟未覆盖的形态(防御)→ 调用方整池降级透传。 +fn rewrite_charstring( + b: &[u8], + start: usize, + end: usize, + frame_key: u32, + sorted_refs: &[u32], + old_local_bias: i32, + masks: &HashMap<(u32, u32), u16>, +) -> Option> { + let new_local_bias = subr_bias(sorted_refs.len()); + let clamped_end = end.min(b.len()); + // 容量上界:callsubr 重编码最长 5 字节(原最长 5 字节),少量富余即可 + let mut out: Vec = Vec::with_capacity(clamped_end.saturating_sub(start) + 16); + // 最近一次入栈的源流字面量(值 + 输出中起始写位置);None = 不可作调用编号 + let mut pending: Option<(i32, usize)> = None; + let mut p = start; + while p < clamped_end { + let b0 = b[p]; + p += 1; + if b0 >= 32 { + let wp_start = out.len(); + if b0 <= 246 { + pending = Some((b0 as i32 - 139, wp_start)); + out.push(b0); + } else if b0 == 255 { + // fixed point:不可作调用编号 + pending = None; + out.extend_from_slice(&b[p - 1..p + 4]); + p += 4; + } else if b0 <= 250 { + pending = Some(((b0 as i32 - 247) * 256 + u8_at(b, p) as i32 + 108, wp_start)); + out.push(b0); + out.push(u8_at(b, p)); + p += 1; + } else { + pending = Some((-(b0 as i32 - 251) * 256 - u8_at(b, p) as i32 - 108, wp_start)); + out.push(b0); + out.push(u8_at(b, p)); + p += 1; + } + } else if b0 == 28 { + pending = Some((i16_at(b, p) as i32, out.len())); + out.push(28); + out.push(u8_at(b, p)); + out.push(u8_at(b, p + 1)); + p += 2; + } else if b0 == 12 { + // escape 算术/逻辑:消费操作数,结果不可作调用编号 + out.push(12); + out.push(u8_at(b, p)); + p += 1; + pending = None; + } else if b0 == T2_HINTMASK || b0 == T2_CNTRMASK { + let op_pos = p - 1; + // 掩码字节原样拷贝,跳宽查预模拟表(物理宽度 = 各执行点宽度,预模拟已校验一致) + let skip = *masks.get(&(frame_key, op_pos as u32))? as usize; + out.push(b0); + for j in 0..skip { + out.push(u8_at(b, p + j)); + } + p += skip; + pending = None; + } else if b0 == T2_HSTEM || b0 == T2_VSTEM || b0 == T2_HSTEMHM || b0 == T2_VSTEMHM { + out.push(b0); + pending = None; + } else if b0 == T2_CALLSUBR { + let (lv, wp_start) = pending?; + let old_sn = lv + old_local_bias; + let new_sn = if old_sn >= 0 { remap_lookup(sorted_refs, old_sn as u32) } else { None }; + match new_sn { + None => { + // subr 未保留(refs 闭包保证不发生):保底保留原 operand + out.push(T2_CALLSUBR); + } + Some(sn) => { + // 截断到 operand 起始,重编码新编号(编码长度可能变化) + out.truncate(wp_start); + let mut ew = W { buf: out }; + ew.dict_int(sn as i32 - new_local_bias); + out = ew.buf; + out.push(T2_CALLSUBR); + } + } + pending = None; + } else if b0 == T2_CALLGSUBR { + // global subr 不子集化:operand 已随扫描原样复制,bias 不变 + out.push(T2_CALLGSUBR); + pending = None; + } else if b0 == T2_ENDCHAR { + out.push(b0); + break; + } else { + // return/绘图/其它操作码:透传;操作数已被消费 + out.push(b0); + pending = None; + } + } + Some(out) +} + +// --------------------------------------------------------------------------- +// INDEX / charset / FDSelect 编码 +// --------------------------------------------------------------------------- + +/// 序列化 CFF INDEX:count + offSize + (count+1)*offSize 偏移量 + 数据拼接。 +/// offSize 选容纳最大偏移量的最小字节数;偏移量 1-based(首个 offset=1)。 +fn write_index(objects: &[&[u8]]) -> Vec { + let count = objects.len(); + if count == 0 { + // count=0 的空 INDEX 仅 2 字节 + return vec![0, 0]; + } + let total_data: usize = objects.iter().map(|o| o.len()).sum(); + let max_offset = total_data + 1; + + // offSize 选择复刻 TS writeIndex 的既有算法:初始 if/else 后 while 还会再 ++, + // 故 maxOffset>0xff 时实际 offSize = 2+floor(log256(maxOffset/256))+1(如 9729 得 3 而非 2)。 + // 字节级对拍要求 bug-for-bug 一致(Top DICT INDEX 的 patchedTopDictOffSize 才是普通最小规则)。 + let mut off_size: u8 = 1; + if max_offset > 0xffff { + off_size = 4; + } else if max_offset > 0xff { + off_size = 2; + } + let mut tmp = max_offset; + while tmp > 0xff && off_size < 4 { + off_size += 1; + tmp >>= 8; + } + + let offsets_size = (count + 1) * off_size as usize; + let mut out = vec![0u8; 2 + 1 + offsets_size + total_data]; + out[0] = ((count >> 8) & 0xff) as u8; + out[1] = (count & 0xff) as u8; + out[2] = off_size; + + // 写偏移量(1-based 大端 offSize 字节) + let mut op: usize = 3; + let mut acc: u32 = 1; + for oi in 0..=count { + let mut s: i32 = off_size as i32 * 8 - 8; + while s >= 0 { + out[op] = ((acc >> s) & 0xff) as u8; + op += 1; + s -= 8; + } + if oi < count { + acc += objects[oi].len() as u32; + } + } + + // 写数据 + let mut dp: usize = 3 + offsets_size; + for o in objects { + out[dp..dp + o.len()].copy_from_slice(o); + dp += o.len(); + } + out +} + +/// 按需查询单个原始 gid 的 FD index(格式 0 直接取字节;格式 3 二分找最后一个 first<=gid 的 range) +fn lookup_fd_select(b: &[u8], fd_select_off: usize, gid: usize) -> u32 { + let fmt = u8_at(b, fd_select_off); + if fmt == 0 { + return u8_at(b, fd_select_off + 1 + gid) as u32; + } + // format 3:ranges 起始 = fdSelectOff + 3,每 range 3 字节 [first(u16), fd(u8)],尾接 sentinel(u16) + let n_ranges = u16_at(b, fd_select_off + 1) as usize; + if n_ranges == 0 { + return 0; + } + let ranges_start = fd_select_off + 3; + let mut lo: usize = 0; + let mut hi: usize = n_ranges - 1; + while lo < hi { + let mid = (lo + hi + 1) >> 1; + let first = u16_at(b, ranges_start + mid * 3) as usize; + if first <= gid { + lo = mid; + } else { + hi = mid - 1; + } + } + u8_at(b, ranges_start + lo * 3 + 2) as u32 +} + +/// 编码 FDSelect:单 FD 用格式 0(最省);多 FD 用格式 3 ranges(连续相同 FD 合并, +/// 与原始 CID 字体结构一致,规避 OTS 严格校验) +struct FdRange { + first: u16, + fd: u16, +} + +fn encode_fd_select(gid_to_fd: &[u16]) -> Vec { + let mut w = W::new(); + // 单 FD 判定(空表 → 非 single,但后续 ranges 循环产出空 ranges + 单 sentinel,与 Zig 一致) + let is_single = match gid_to_fd.first() { + None => false, + Some(&first) => gid_to_fd.iter().all(|&fd| fd == first), + }; + if is_single { + w.w8(0); + for &fd in gid_to_fd { + // @intCast:fd >255 时 Zig 会 panic,合法字体 FD 编号恒 <256 + w.w8(fd as u8); + } + return w.buf; + } + // 多 FD:格式 3 ranges + w.w8(3); + let mut ranges: Vec = Vec::new(); + let mut cur_first: usize = 0; + let mut cur_fd: u16 = gid_to_fd.first().copied().unwrap_or(0); + for (i, &fd) in gid_to_fd.iter().enumerate() { + if i == 0 { + continue; + } + if fd != cur_fd { + // @intCast:gid 数 >65535 时 Zig 会 panic,CFF numGlyphs 上限 65535 + ranges.push(FdRange { first: cur_first as u16, fd: cur_fd }); + cur_first = i; + cur_fd = fd; + } + } + ranges.push(FdRange { first: cur_first as u16, fd: cur_fd }); + w.w16(ranges.len() as u16); + for r in &ranges { + w.w16(r.first); + w.w8(r.fd as u8); + } + // sentinel = numGlyphs(最后一个 range 之后的第一个 gid) + w.w16(gid_to_fd.len() as u16); + w.buf +} + +/// 按需查询单个原始 gid 的 CID/SID。格式 0 直接取(charset 表不含 gid 0); +/// 格式 1/2 遍历 range 找覆盖 gid 的(range 数远小于 numGlyphs)。 +/// charset_off 为 None(Top DICT 无 charset op)时按 ISOAdobe 隐式 charset:编号 = gid。 +fn lookup_charset_cid(b: &[u8], charset_off: Option, gid: u16) -> u32 { + if gid == 0 { + return 0; + } + let co = match charset_off { + Some(v) => v, + None => return gid as u32, + }; + let fmt = u8_at(b, co); + if fmt == 0 { + return u16_at(b, co + 1 + (gid as usize - 1) * 2) as u32; + } + let mut p = co + 1; + let mut range_first_gid: u32 = 1; + if fmt == 1 { + while p + 3 <= b.len() { + let first_cid = u16_at(b, p) as u32; + let n_left = u8_at(b, p + 2) as u32; + if gid as u32 >= range_first_gid && gid as u32 <= range_first_gid + n_left { + return first_cid + (gid as u32 - range_first_gid); + } + range_first_gid += n_left + 1; + p += 3; + } + return 0; + } + // fmt == 2 + while p + 4 <= b.len() { + let first_cid = u16_at(b, p) as u32; + let n_left = u16_at(b, p + 2) as u32; + if gid as u32 >= range_first_gid && gid as u32 <= range_first_gid + n_left { + return first_cid + (gid as u32 - range_first_gid); + } + range_first_gid += n_left + 1; + p += 4; + } + 0 +} + +/// 编码 charset 格式 0:format(1) + cids×(u16) +fn encode_charset_format0(cids: &[u32]) -> Vec { + let mut w = W::new(); + w.w8(0); + for &cid in cids { + w.w16((cid & 0xffff) as u16); + } + w.buf +} + +// --------------------------------------------------------------------------- +// DICT patch +// --------------------------------------------------------------------------- + +/// DICT 单操作码替换项 +struct DictReplace { + op: u32, + val: i32, +} + +/// 替换 DICT 中多个操作码的操作数(offset 值);drops 中的操作码连同其操作数整体删除。 +/// 扫描原 DICT:命中替换项→写新编码操作数+操作码;命中 drop→跳过;其余字节原样保留。 +/// BCD 实数操作数完整跳过(如 CIDFontVersion)。 +fn replace_dict_offsets(dict_bytes: &[u8], replacements: &[DictReplace], drops: &[u32]) -> Vec { + let mut w = W::new(); + w.buf.reserve(dict_bytes.len() + replacements.len() * 4 + 16); + let mut p: usize = 0; + let mut operand_start: usize = 0; + let l = dict_bytes.len(); + while p < l { + let b0 = dict_bytes[p]; + p += 1; + if b0 <= 21 { + let op: u32 = if b0 == 12 { + let o = (12u32 << 8) | u8_at(dict_bytes, p) as u32; + p += 1; + o + } else { + b0 as u32 + }; + let mut replaced = false; + let mut dropped = false; + for r in replacements { + if r.op == op { + w.dict_int(r.val); + if op >= 256 { + w.w8(12); + w.w8((op & 0xff) as u8); + } else { + w.w8(op as u8); + } + replaced = true; + break; + } + } + if !replaced { + for &d in drops { + if d == op { + dropped = true; + break; + } + } + } + if !replaced && !dropped { + w.w_bytes(&dict_bytes[operand_start..p]); + } + operand_start = p; + } else if b0 == 28 { + p += 2; + } else if b0 == 29 { + p += 4; + } else if b0 == 30 { + while p < l { + let byte = dict_bytes[p]; + p += 1; + if (byte >> 4) == 0xf || (byte & 0xf) == 0xf { + break; + } + } + } else if (247..=254).contains(&b0) { + p += 1; + } + // 32~246 单字节操作数,无后续 + } + w.buf +} + +/// 替换 DICT 的 Private 操作数 [length, offset](Top DICT / FD DICT 共用)。 +/// 扫描定位操作码 18,将其前两个操作数替换为新编码 [priv_len, new_priv_off],其余字节原样保留。 +fn replace_dict_private_operands(dict_bytes: &[u8], priv_len: i32, new_priv_off: i32) -> Vec { + let mut w = W::new(); + let mut p: usize = 0; + let mut operand_start: usize = 0; + let l = dict_bytes.len(); + while p < l { + let b0 = dict_bytes[p]; + p += 1; + if b0 <= 21 { + let op: u32 = if b0 == 12 { + let o = (12u32 << 8) | u8_at(dict_bytes, p) as u32; + p += 1; + o + } else { + b0 as u32 + }; + if op == OP_PRIVATE { + w.dict_int(priv_len); + w.dict_int(new_priv_off); + w.w8(18); + } else { + w.w_bytes(&dict_bytes[operand_start..p]); + } + operand_start = p; + } else if b0 == 28 { + p += 2; + } else if b0 == 29 { + p += 4; + } else if b0 == 30 { + while p < l { + let byte = dict_bytes[p]; + p += 1; + if (byte >> 4) == 0xf || (byte & 0xf) == 0xf { + break; + } + } + } else if (247..=254).contains(&b0) { + p += 1; + } + } + w.buf +} + +/// patch Private DICT 的 Local Subr 操作数(op 19),使其指向新 DICT 长度 +/// (Local Subr INDEX 紧跟 Private DICT 字节之后)。op19 编码长度随值变化(影响 DICT 总长), +/// 迭代至稳定。无 Local Subr(has_subr=false)的 Private 原样透传。 +fn patch_private_dict(b: &[u8], priv_orig_off: usize, priv_len: usize, has_subr: bool) -> Vec { + if !has_subr { + return b[priv_orig_off..priv_orig_off + priv_len].to_vec(); + } + let mut cur: Vec = b[priv_orig_off..priv_orig_off + priv_len].to_vec(); + for _ in 0..4 { + let patched = replace_dict_offsets(&cur, &[DictReplace { op: OP_LOCAL_SUBR, val: cur.len() as i32 }], &[]); + if patched.len() == cur.len() { + return patched; + } + cur = patched; + } + cur +} + +// --------------------------------------------------------------------------- +// Private 池(Local Subr 子集化) +// --------------------------------------------------------------------------- + +/// 一个 Private 段(CID 多 FD 共享去重;非 CID 单池)的 Local Subr 子集化上下文 +struct PrivPool { + /// 原 Private DICT 绝对偏移(NO_PRIV = 无 Private) + orig_off: usize, + /// 原 Private DICT 字节长度(不含 Local Subr INDEX) + len: usize, + /// Local Subr INDEX 头部(None = 无 Local Subr) + idx: Option, + /// 原 local subr bias + local_bias: i32, + /// 收集到的 subr 引用(fixpoint 收敛后为闭包) + refs: HashSet, + /// 引用闭包的升序数组(新编号 = 数组下标);None = 无 subr + sorted_refs: Option>, + /// 重建后的 Local Subr INDEX 字节(无 subr 为空 INDEX 2 字节) + new_local_subr: Vec, + /// 执行级预模拟记录(降级透传池为 None) + rec: Option, +} + +impl PrivPool { + /// 创建一个无 Private 的占位池(FD 无 Private 时的 FDArray 透传占位,不会被字形引用) + fn empty_placeholder() -> PrivPool { + PrivPool { + orig_off: NO_PRIV, + len: 0, + idx: None, + local_bias: 0, + refs: HashSet::new(), + sorted_refs: None, + new_local_subr: Vec::new(), + rec: None, + } + } +} + +/// 解析 Private DICT 的 op19(Local Subr INDEX 相对 Private 起始的偏移)并初始化池 +fn init_pool_subrs(b: &[u8], pool: &mut PrivPool) { + let priv_dict = parse_dict(b, pool.orig_off, pool.orig_off + pool.len); + let subr_rel = match priv_dict.get(&OP_LOCAL_SUBR) { + Some(v) => v, + None => return, + }; + if subr_rel.is_empty() { + return; + } + // @intCast:负偏移时 Zig 会 panic,合法字体 op19 非负 + let subr_abs = pool.orig_off + subr_rel[0] as usize; + let idx = read_index_header(b, subr_abs); + pool.local_bias = subr_bias(idx.count); + pool.idx = Some(idx); +} + +/// 取或创建 Private 池(相同 orig_off 的 Private 共享一份,多 FD 合并引用集)。 +/// 返回 pools 数组下标(Zig 版以 *PrivPool 指针共享,Rust 版以下标等价)。 +fn get_or_create_pool( + b: &[u8], + priv_orig_off: usize, + priv_len: usize, + pool_by_orig: &mut HashMap, + pools: &mut Vec, +) -> usize { + if let Some(&idx) = pool_by_orig.get(&priv_orig_off) { + return idx; + } + let mut pool = PrivPool { + orig_off: priv_orig_off, + len: priv_len, + idx: None, + local_bias: 0, + refs: HashSet::new(), + sorted_refs: None, + new_local_subr: Vec::new(), + rec: None, + }; + init_pool_subrs(b, &mut pool); + let idx = pools.len(); + pools.push(pool); + pool_by_orig.insert(priv_orig_off, idx); + idx +} + +// --------------------------------------------------------------------------- +// 子集化主入口 +// --------------------------------------------------------------------------- + +/// CFF 表子集化(对译 subsetCFF)。 +/// * `subset_gids` - 子集字形原始 gid 顺序(含 0 = .notdef,新 gid = 数组索引) +/// * 返回 - 子集 CFF 字节;结构不支持返回 None(调用方降级) +pub fn subset_cff(cff_tbl: &[u8], subset_gids: &[u16]) -> Result>, CffError> { + let b = cff_tbl; + if b.len() < 4 { + return Ok(None); + } + // Header: major(1) minor(1) hdrSize(1) offSize(1) + let hdr_size = b[2] as usize; + if hdr_size >= b.len() { + return Ok(None); + } + // Name INDEX 紧接 Header(仅需字节范围透传) + let name_hdr = read_index_header(b, hdr_size); + // Top DICT INDEX 紧接 Name INDEX + let top_dict_index = read_index_full(b, name_hdr.end); + if top_dict_index.count < 1 { + return Ok(None); + } + + let td_start = top_dict_index.data_start + top_dict_index.offsets[0] as usize - 1; + let td_end = top_dict_index.data_start + top_dict_index.offsets[1] as usize - 1; + let top_dict = parse_dict(b, td_start, td_end); + + // 非 CID 字体(无 ROS)走 name-keyed 单 Private 路径;CID 走 FDArray/FDSelect 路径 + let is_cid = top_dict.contains_key(&OP_ROS); + let ctx = CffContext { + name_hdr, + top_dict_index, + td_start, + td_end, + top_dict: &top_dict, + is_cid, + }; + Ok(Some(subset_cff_common(b, subset_gids, &ctx)?)) +} + +/// FD DICT(CID)或占位(无 Private)的记录 +struct FdInfo<'a> { + /// 原 FD DICT 字节 + dict_bytes: &'a [u8], + /// 关联 Private 池(pools 数组下标) + pool_idx: usize, + /// 是否有 Private(无则 FD DICT 原样透传) + has_priv: bool, +} + +/// 共用实现的上下文(CID / 非 CID 两条路径的结构差异集中在 FDArray/FDSelect/Private 来源) +struct CffContext<'a> { + name_hdr: IndexHeader, + top_dict_index: FullIndex, + td_start: usize, + td_end: usize, + top_dict: &'a HashMap>, + is_cid: bool, +} + +/// 共用实现(CID / 非 CID 两条路径的结构差异集中在 FDArray/FDSelect/Private 来源) +fn subset_cff_common(b: &[u8], subset_gids: &[u16], ctx: &CffContext) -> Result, CffError> { + let td = ctx.top_dict; + let is_cid = ctx.is_cid; + + let charset_op = td.get(&OP_CHARSET); + // @intCast:负 offset 时 Zig 会 panic,合法字体 DICT offset 非负 + let charset_off: Option = charset_op.map(|o| o[0] as usize); + let fd_array_op = td.get(&OP_FD_ARRAY); + let fd_select_op = td.get(&OP_FD_SELECT); + // 非 CID:Private 挂 Top DICT;CID:FDArray/FDSelect 必需 + let plain_priv_op = if !is_cid { td.get(&OP_PRIVATE) } else { None }; + + let char_strings_op = match td.get(&OP_CHARSTRINGS) { + Some(v) => v, + None => return Err(CffError::UnsupportedCff), + }; + if is_cid && (charset_op.is_none() || fd_array_op.is_none() || fd_select_op.is_none()) { + return Err(CffError::UnsupportedCff); + } + + // String INDEX / Global Subr INDEX(字节范围透传) + let string_hdr = read_index_header(b, ctx.top_dict_index.end); + let gsubr_hdr = read_index_header(b, string_hdr.end); + + // CharStrings INDEX 头部(count + offSize),不全量解析 offset(思源 65535 glyph),按 gid 随机读 + let cs_off = char_strings_op[0] as usize; + let cs_off_size = u8_at(b, cs_off + 2); + let cs_off_arr_start = cs_off + 3; + let cs_data_start = cs_off_arr_start + (u16_at(b, cs_off) as usize + 1) * cs_off_size as usize; + if subset_gids.is_empty() { + return Err(CffError::UnsupportedCff); + } + + // .notdef(gid 0)必须保留且在首位 + let new_gids: Vec = if subset_gids[0] != 0 { + let mut arr = Vec::with_capacity(subset_gids.len() + 1); + arr.push(0); + arr.extend_from_slice(subset_gids); + arr + } else { + subset_gids.to_vec() + }; + let n_glyphs = new_gids.len(); + + // 每个子集字形在原 CharStrings 的字节区间 [start, end) + let mut cs_ranges: Vec<[usize; 2]> = Vec::with_capacity(n_glyphs); + for &gid in &new_gids { + let o0 = index_offset_at(b, cs_off_arr_start, cs_off_size, gid as usize); + let o1 = index_offset_at(b, cs_off_arr_start, cs_off_size, gid as usize + 1); + cs_ranges.push([cs_data_start + o0 as usize - 1, cs_data_start + o1 as usize - 1]); + } + + // 每个子集字形的 charstring 是否含 CALLSUBR(决定是否需 rewrite) + let mut gid_has_subr = vec![false; n_glyphs]; + + // 重建 charset:格式 0,gid 1..n-1 的 CID/SID(gid 0 隐式为 0 不入表) + let mut charset_cids: Vec = Vec::with_capacity(n_glyphs - 1); + for i in 1..n_glyphs { + charset_cids.push(lookup_charset_cid(b, charset_off, new_gids[i])); + } + let charset_seg = encode_charset_format0(&charset_cids); + + // ---- FD/Private 池 ---- + // CID:原FD→新FD 映射 + 每 gid 的原 FD;非 CID:单池(Top DICT op 18) + let mut pools: Vec = Vec::new(); + let mut fd_remap: HashMap = HashMap::new(); + let mut gid_orig_fds: Vec = Vec::new(); + let mut fd_infos: Vec = Vec::new(); + let mut pool_by_orig: HashMap = HashMap::new(); + + if is_cid { + let fd_select_off = fd_select_op.unwrap()[0] as usize; + let mut used_fds: Vec = Vec::new(); + for &gid in &new_gids { + let fd = lookup_fd_select(b, fd_select_off, gid as usize); + gid_orig_fds.push(fd); + if let Entry::Vacant(e) = fd_remap.entry(fd) { + e.insert(used_fds.len()); + used_fds.push(fd); + } + } + + let fd_array_index = read_index_full(b, fd_array_op.unwrap()[0] as usize); + for &fd in &used_fds { + let fdu = fd as usize; + let s = fd_array_index.data_start + fd_array_index.offsets[fdu] as usize - 1; + let e = fd_array_index.data_start + fd_array_index.offsets[fdu + 1] as usize - 1; + let dict_bytes = &b[s..e]; + let fd_dict = parse_dict(b, s, e); + let priv_op = match fd_dict.get(&OP_PRIVATE) { + Some(v) if v.len() >= 2 => v, + _ => { + // 无 Private 的 FD(极罕见):FD DICT 原样透传 + pools.push(PrivPool::empty_placeholder()); + fd_infos.push(FdInfo { dict_bytes, pool_idx: pools.len() - 1, has_priv: false }); + continue; + } + }; + let priv_len = priv_op[0] as usize; + let priv_orig_off = priv_op[1] as usize; + let pool_idx = get_or_create_pool(b, priv_orig_off, priv_len, &mut pool_by_orig, &mut pools); + fd_infos.push(FdInfo { dict_bytes, pool_idx, has_priv: true }); + } + } else { + // 非 CID:单 Private 池(来自 Top DICT op 18) + let pool = if plain_priv_op.map_or(false, |v| v.len() >= 2) { + let v = plain_priv_op.unwrap(); + let mut p = PrivPool { + // @intCast:负 len/offset 时 Zig 会 panic,合法字体非负 + orig_off: v[1] as usize, + len: v[0] as usize, + idx: None, + local_bias: 0, + refs: HashSet::new(), + sorted_refs: None, + new_local_subr: Vec::new(), + rec: None, + }; + init_pool_subrs(b, &mut p); + p + } else { + PrivPool::empty_placeholder() + }; + pools.push(pool); + } + + // 引用闭包收敛 + 执行级 stem 预模拟 + 旧→新映射 + 重建 Local Subr INDEX + let gsubr_bias = subr_bias(gsubr_hdr.count); + // 每 pool 负责的子集 gid 列表(执行级预模拟范围) + let mut pool_gids: Vec> = vec![Vec::new(); pools.len()]; + if is_cid { + for i in 0..n_glyphs { + if let Some(&fd_idx) = fd_remap.get(&gid_orig_fds[i]) { + if fd_infos[fd_idx].has_priv { + pool_gids[fd_infos[fd_idx].pool_idx].push(i); + } + } + } + } else { + pool_gids[0] = (0..n_glyphs).collect(); + } + // per-gid 栈深超限标志(预模拟执行级真栈峰值,分发期免二次模拟) + let mut gid_overflow = vec![false; n_glyphs]; + // per-pool 预重写好的 charstring 字节(gi → bytes),dispatch 直接取用 + let mut pool_cs_rewritten: Vec>>> = vec![None; pools.len()]; + for pi in 0..pools.len() { + if pools[pi].idx.is_none() { + continue; + } + // 注:引用闭包不再做语法扫描 fixpoint(hintmask 跳宽错位会漏收集),执行级 + // analyze 的 rec.refs 即精确闭包(递归覆盖嵌套),见 EntryRec.refs 注释 + let sim = SimCtx { + idx: pools[pi].idx.unwrap(), + local_bias: pools[pi].local_bias, + gsubr_hdr, + gsubr_bias, + }; + // 执行级预模拟:OTS 的 operand 栈与 num_stems 跨 callsubr 边界共享, + // 「subr 消费调用方压栈操作数」模式(思源 Bold subr5572)静态线性扫描原理上无法计数; + // 记录各 subr 进入/返回时刻的精确状态(rewrite/strip 查表 O(1) 推进)与 per-gid 栈深超限标志。 + // 不可分析(病态流/调用点效应不一致)或 gsubr 体内 callsubr 时该池降级透传 + let (rec, ovf, has_subr, gcl) = analyze_entry_stems(b, &pool_gids[pi], &cs_ranges, &sim); + // gsubr 体内含 callsubr:local subr 不可重编号(透传 gsubr 的 operand 仍指旧编号), + // Local Subr INDEX 原样保留(仅 patch op19 偏移),charstring 走透传/剥 hint 路径。 + // 执行级 per-pool 判定:仅本池字形执行路径可达的 gsubr 命中才算,替代全 INDEX 扫描 + if gcl || !rec.consistent || rec.bad_mask { + let idx = pools[pi].idx.as_ref().unwrap(); + pools[pi].new_local_subr = b[idx.start..idx.end].to_vec(); + continue; + } + for &gi in &pool_gids[pi] { + gid_overflow[gi] = ovf[gi]; + gid_has_subr[gi] = has_subr[gi]; + } + // 执行级 refs 并入(语法扫描可能因 mask 跳宽错位漏收集,见 EntryRec.refs 注释) + pools[pi].refs.extend(rec.refs.iter().copied()); + let mut sorted: Vec = pools[pi].refs.iter().copied().collect(); + sorted.sort_unstable(); + // 语法级重写池内含 CALLSUBR 的字形与被引用 subr body(任一遇预模拟未覆盖的形态 + // → 整池降级透传:cs 重写必须在 INDEX 重写前完成,否则降级无法回滚已改编号的 INDEX) + let idx = pools[pi].idx.as_ref().unwrap(); + let mut cs_rewritten: HashMap> = HashMap::new(); + let mut deg = false; + for &gi in &pool_gids[pi] { + if !gid_has_subr[gi] { + continue; + } + let r = &cs_ranges[gi]; + match rewrite_charstring(b, r[0].min(b.len()), r[1].min(b.len()), gi as u32, &sorted, pools[pi].local_bias, &rec.cs_masks) { + Some(obj) => { + cs_rewritten.insert(gi, obj); + } + None => { + deg = true; + break; + } + } + } + let mut objects_owned: Vec> = Vec::new(); + if !deg && !sorted.is_empty() { + // 重建 INDEX:按新顺序写出被引用 subr 的重写字节(subr 内部 callsubr 也需重映射) + for &old_sn in &sorted { + let ss = idx.data_start + index_offset_at(b, idx.off_base, idx.off_size, old_sn as usize) as usize - 1; + let se = idx.data_start + index_offset_at(b, idx.off_base, idx.off_size, old_sn as usize + 1) as usize - 1; + match rewrite_charstring(b, ss, se, old_sn, &sorted, pools[pi].local_bias, &rec.sn_masks) { + Some(obj) => objects_owned.push(obj), + None => { + deg = true; + break; + } + } + } + } + if deg { + for &gi in &pool_gids[pi] { + gid_overflow[gi] = false; + } + pools[pi].new_local_subr = b[idx.start..idx.end].to_vec(); + continue; + } + pools[pi].rec = Some(rec); + pools[pi].sorted_refs = Some(sorted); + pool_cs_rewritten[pi] = Some(cs_rewritten); + if objects_owned.is_empty() { + // 无引用:输出空 INDEX(count=0,2 字节) + pools[pi].new_local_subr = write_index(&[]); + } else { + let objects: Vec<&[u8]> = objects_owned.iter().map(|v| v.as_slice()).collect(); + pools[pi].new_local_subr = write_index(&objects); + } + } + + // 重建 CharStrings INDEX:含 CALLSUBR 的字形 rewrite(重映射 local subr 编号); + // OTS 栈深超限的剥 hint;否则透传原字节。global subr 不子集化,callgsubr operand 原样保留。 + let mut cs_objects_owned: Vec> = Vec::with_capacity(n_glyphs); + for (gi, r) in cs_ranges.iter().enumerate() { + let pool_idx: Option = if is_cid { + match fd_remap.get(&gid_orig_fds[gi]) { + Some(&fd_idx) if fd_infos[fd_idx].has_priv => Some(fd_infos[fd_idx].pool_idx), + _ => None, + } + } else { + Some(0) + }; + let has_remap = match pool_idx { + Some(pi) => pools[pi].sorted_refs.as_ref().is_some_and(|s| !s.is_empty()), + None => false, + }; + // 本字形所属池的模拟上下文(无 Private 时用空占位,callsubr 按不可分析处理) + let sim = match pool_idx { + Some(pi) => { + let pl = &pools[pi]; + SimCtx { + idx: pl.idx.unwrap_or_else(|| SimCtx::empty(gsubr_hdr).idx), + local_bias: pl.local_bias, + gsubr_hdr, + gsubr_bias, + } + } + None => SimCtx::empty(gsubr_hdr), + }; + // 池级预模拟记录(降级透传池 / 无 Private 池为 None) + let pool_rec = pool_idx.and_then(|pi| pools[pi].rec.as_ref()); + let obj: Vec = if pool_idx.is_some() && has_remap && gid_has_subr[gi] { + // pool 循环已预重写并校验过(任一失败整池降级),此处直接取用 + pool_cs_rewritten[pool_idx.unwrap()].as_mut().unwrap().remove(&gi).unwrap() + } else if pool_rec.is_some() && gid_overflow[gi] { + // 思源等源字体有字形 operand 栈深 >48(Adobe 合规但 OTS 拒收),剥 hint 区 + strip_hints(b, r[0], r[1], &sim, pool_rec) + } else if pool_rec.is_none() && charstring_stack_overflows(b, r[0], r[1], &sim) { + // 降级池(无预模拟记录):逐字形模拟判定栈深 + strip_hints(b, r[0], r[1], &sim, None) + } else { + let s = r[0].min(b.len()); + let e = r[1].min(b.len()); + b[s..e].to_vec() + }; + cs_objects_owned.push(obj); + } + let cs_objects: Vec<&[u8]> = cs_objects_owned.iter().map(|v| v.as_slice()).collect(); + let charstrings_seg = write_index(&cs_objects); + + // 新 FDSelect(CID):单 FD 格式 0(最省)/ 多 FD 格式 3 ranges + let mut fdselect_seg: Vec = Vec::new(); + if is_cid { + let mut new_gid_to_fd: Vec = Vec::with_capacity(n_glyphs); + for i in 0..n_glyphs { + new_gid_to_fd.push(fd_remap.get(&gid_orig_fds[i]).copied().unwrap_or(0) as u16); + } + fdselect_seg = encode_fd_select(&new_gid_to_fd); + } + + // ---- 组装:Header+Name + TopDICT INDEX + String + GlobalSubr + charset + CharStrings + // + [FDArray + FDSelect] + Private 段;Top DICT / FD DICT / Private op19 偏移联合迭代收敛 + // (三者 patch 后长度互相影响后续偏移,用长度不变做收敛判定)---- + let header_name = &b[0..ctx.name_hdr.end]; + let string_seg = &b[string_hdr.start..string_hdr.end]; + let gsubr_seg = &b[gsubr_hdr.start..gsubr_hdr.end]; + let top_dict_bytes = &b[ctx.td_start..ctx.td_end]; + + // 去重后的唯一 Private 池(按 fd_infos 首现序;非 CID 单池),存 pools 下标(Zig 版为指针去重) + let mut unique_pools: Vec = Vec::new(); + if is_cid { + for fi in &fd_infos { + if !fi.has_priv { + continue; + } + if !unique_pools.contains(&fi.pool_idx) { + unique_pools.push(fi.pool_idx); + } + } + } else { + unique_pools.push(0); + } + + let mut top_dict_len = top_dict_bytes.len(); + let mut fd_array_total_len: usize = 0; + let mut priv_segs_total: usize = 0; + let mut patched_top_dict: Vec = top_dict_bytes.to_vec(); + let mut new_fd_array: Vec = Vec::new(); + let mut patched_priv_segs: Vec> = Vec::new(); + + for _iter in 0..8 { + // patch 各唯一 Private DICT:op19 = 新 DICT 长度(Local Subr INDEX 紧跟其后) + let mut priv_segs: Vec> = Vec::with_capacity(unique_pools.len()); + let mut cur_priv_total: usize = 0; + for &pi in &unique_pools { + let seg = if pools[pi].orig_off == NO_PRIV { + Vec::new() + } else { + patch_private_dict(b, pools[pi].orig_off, pools[pi].len, pools[pi].idx.is_some()) + }; + cur_priv_total += seg.len() + pools[pi].new_local_subr.len(); + priv_segs.push(seg); + } + + // 各段偏移(Top DICT INDEX 总长 = count(2)+offSize(1)+(1+1)*offSize + topDictLen,count=1) + let td_off_size = top_dict_off_size(top_dict_len + 1); + let td_idx_total_len = 2 + 1 + 2 * td_off_size as usize + top_dict_len; + let string_off = header_name.len() + td_idx_total_len; + let gsubr_off = string_off + string_seg.len(); + let charset_off2 = gsubr_off + gsubr_seg.len(); + let char_strings_off2 = charset_off2 + charset_seg.len(); + let fd_array_off = char_strings_off2 + charstrings_seg.len(); + let fd_select_off = fd_array_off + fd_array_total_len; + let private_off = fd_select_off + fdselect_seg.len(); + + // 各唯一 Private 段的新绝对偏移(顺序拼接,起始 privateOff) + let mut p_acc = private_off; + let mut pool_new_offs: Vec = Vec::with_capacity(unique_pools.len()); + for (i, &pi) in unique_pools.iter().enumerate() { + pool_new_offs.push(p_acc); + p_acc += priv_segs[i].len() + pools[pi].new_local_subr.len(); + } + + let candidate_top_dict: Vec; + let mut fd_converged = true; + if is_cid { + // patch FD DICT 的 Private [len, offset]:len = patched DICT 长度(不含 Local Subr), + // offset = 新 Private 绝对偏移(CFF 规范 Private len 是 DICT 字节长度,Local Subr 在其外) + let mut fd_objects_owned: Vec> = Vec::with_capacity(fd_infos.len()); + for fi in &fd_infos { + if !fi.has_priv { + fd_objects_owned.push(fi.dict_bytes.to_vec()); + } else { + let uid = unique_pools.iter().position(|&up| up == fi.pool_idx).unwrap(); + fd_objects_owned.push(replace_dict_private_operands( + fi.dict_bytes, + priv_segs[uid].len() as i32, + pool_new_offs[uid] as i32, + )); + } + } + let fd_objects: Vec<&[u8]> = fd_objects_owned.iter().map(|v| v.as_slice()).collect(); + let candidate_fd_array = write_index(&fd_objects); + fd_converged = candidate_fd_array.len() == fd_array_total_len; + new_fd_array = candidate_fd_array; + fd_array_total_len = new_fd_array.len(); + // patch Top DICT:charset/CharStrings/FDArray/FDSelect + candidate_top_dict = replace_dict_offsets( + top_dict_bytes, + &[ + DictReplace { op: OP_CHARSET, val: charset_off2 as i32 }, + DictReplace { op: OP_CHARSTRINGS, val: char_strings_off2 as i32 }, + DictReplace { op: OP_FD_ARRAY, val: fd_array_off as i32 }, + DictReplace { op: OP_FD_SELECT, val: fd_select_off as i32 }, + ], + &[], + ); + } else { + // 非 CID:patch charset/CharStrings,删除 Encoding(子集后其内部 glyph 索引已失效, + // 浏览器消费 cmap 不消费 CFF encoding),再替换 Private [len, offset](仅当有 Private) + let mut td1 = replace_dict_offsets( + top_dict_bytes, + &[ + DictReplace { op: OP_CHARSET, val: charset_off2 as i32 }, + DictReplace { op: OP_CHARSTRINGS, val: char_strings_off2 as i32 }, + ], + &[OP_ENCODING], + ); + if pools[unique_pools[0]].orig_off != NO_PRIV { + td1 = replace_dict_private_operands(&td1, priv_segs[0].len() as i32, pool_new_offs[0] as i32); + } + candidate_top_dict = td1; + } + + // 收敛判定:Top DICT / FDArray(CID)/ Private 段总长都不变 + let td_converged = candidate_top_dict.len() == top_dict_len; + let priv_converged = cur_priv_total == priv_segs_total; + patched_top_dict = candidate_top_dict; + patched_priv_segs = priv_segs; + top_dict_len = patched_top_dict.len(); + priv_segs_total = cur_priv_total; + if td_converged && priv_converged && fd_converged { + break; + } + } + + let new_top_dict_index = write_index(&[&patched_top_dict]); + + // 拼接 Private 段(每段 = patched DICT + Local Subr INDEX) + let mut parts: Vec<&[u8]> = Vec::new(); + parts.push(header_name); + parts.push(&new_top_dict_index); + parts.push(string_seg); + parts.push(gsubr_seg); + parts.push(&charset_seg); + parts.push(&charstrings_seg); + if is_cid { + parts.push(&new_fd_array); + parts.push(&fdselect_seg); + } + for (i, &pi) in unique_pools.iter().enumerate() { + parts.push(&patched_priv_segs[i]); + parts.push(&pools[pi].new_local_subr); + } + Ok(combine(&parts)) +} + +/// 计算 Top DICT INDEX 的 offSize(容纳 max_offset 的最小字节数,1~4) +fn top_dict_off_size(max_offset: usize) -> u8 { + if max_offset > 0xffff { + return 4; + } + if max_offset > 0xff { + return 2; + } + 1 +} + +// --------------------------------------------------------------------------- +// 测试 +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + use super::*; + + /// fixture 目录(生成脚本见测试注释;缺失则跳过相关用例) + const FIXTURE_DIR: &str = "/tmp/cff_fixtures"; + /// zig oracle 二进制(/tmp/cff_parity/oracle.zig 编译产物,调用 zig-spike cff.zig) + const ORACLE: &str = "/tmp/cff_parity/oracle"; + + fn have(path: &str) -> bool { + std::path::Path::new(path).exists() + } + + /// 读 fixture 字节 + fn fixture(name: &str) -> Vec { + std::fs::read(format!("{FIXTURE_DIR}/{name}")).expect("fixture read") + } + + /// 跑 zig oracle 得同输入输出字节(写入 /tmp 后读回) + fn run_oracle(tag: &str, input: &str, gids: &str) -> Vec { + let out = format!("{FIXTURE_DIR}/oracle_{tag}.bin"); + let st = std::process::Command::new(ORACLE) + .args([format!("{FIXTURE_DIR}/{input}").as_str(), out.as_str(), gids]) + .output() + .expect("oracle spawn"); + assert!(st.status.success(), "oracle failed: {}", String::from_utf8_lossy(&st.stderr)); + std::fs::read(&out).expect("oracle output read") + } + + /// 结构自检:重建的输出必须能按 CFF 结构走通,且 CharStrings 数量 = 子集字形数 + /// (完整合法性由 fontTools 往返验证,见 /tmp 验证脚本) + fn check_structure(out: &[u8], n_expect: usize) { + assert!(out.len() >= 4); + let hdr_size = out[2] as usize; + let name_hdr = read_index_header(out, hdr_size); + let top_index = read_index_full(out, name_hdr.end); + assert_eq!(top_index.count, 1); + let td_start = top_index.data_start + top_index.offsets[0] as usize - 1; + let td_end = top_index.data_start + top_index.offsets[1] as usize - 1; + let td = parse_dict(out, td_start, td_end); + let cs_op = td.get(&OP_CHARSTRINGS).expect("charstrings op"); + let cs_off = cs_op[0] as usize; + let cs_count = u16_at(out, cs_off) as usize; + assert_eq!(cs_count, n_expect, "charstrings count"); + // charset 段存在且格式 0 + let charset_off = td.get(&OP_CHARSET).expect("charset op")[0] as usize; + assert_eq!(u8_at(out, charset_off), 0); + // 每个 charstring 的字节区间可读(offset 单调、数据不越界) + let cs_off_size = u8_at(out, cs_off + 2); + let cs_off_arr = cs_off + 3; + let cs_data_start = cs_off_arr + (cs_count + 1) * cs_off_size as usize; + let mut prev: usize = 0; + for i in 0..=cs_count { + let o = index_offset_at(out, cs_off_arr, cs_off_size, i) as usize; + assert!(o >= prev, "charstring offset monotonic"); + prev = o; + } + let last = index_offset_at(out, cs_off_arr, cs_off_size, cs_count) as usize; + assert!(cs_data_start + last - 1 <= out.len(), "charstrings data in bounds"); + } + + #[test] + fn invalid_inputs() { + // len < 4 → None(降级路径) + assert!(matches!(subset_cff(&[1, 0, 4], &[0]), Ok(None))); + // hdrSize 越界 → None + assert!(matches!(subset_cff(&[1, 0, 200, 4, 0, 0], &[0]), Ok(None))); + } + + /// 手工最小 CFF:Top DICT 为空(无 CharStrings op)→ UnsupportedCff + #[test] + fn missing_charstrings_unsupported() { + let mut b: Vec = Vec::new(); + b.extend_from_slice(&[1, 0, 4, 4]); // Header hdrSize=4 + // Name INDEX: count=1 offSize=1 offsets=[1,7] data="RustTF" + b.extend_from_slice(&[0x00, 0x01, 0x01, 0x00, 0x01, 0x07]); + b.extend_from_slice(b"RustTF"); + // Top DICT INDEX: count=1 offSize=1 offsets=[1,1] data 空 + b.extend_from_slice(&[0x00, 0x01, 0x01, 0x00, 0x01, 0x01]); + assert!(matches!(subset_cff(&b, &[0, 1]), Err(CffError::UnsupportedCff))); + } + + /// CID(多 FD,FDSelect)与 name-keyed(单 Private + Local Subr)全链路: + /// 结构合法性 + 与 zig oracle 字节对拍 + #[test] + fn parity_cid_and_name() { + if !have(ORACLE) || !have(&format!("{FIXTURE_DIR}/cid_small.bin")) { + eprintln!("skip: oracle/fixture 不存在(见模块头注释生成方式)"); + return; + } + let cases: [(&str, &str, &[&str]); 8] = [ + // cid_small:Noto CID(gsubr 体内含 callsubr → local subr 透传路径) + ("cid_small.bin", "c1", &["0", "1", "2", "5", "9", "20"]), + ("cid_small.bin", "c2", &["0"]), + ("cid_small.bin", "c3", &["3", "7", "11"]), // 无 0 → 注入 .notdef + // cid_nogsubr:gsubr body 置换为 endchar → CID local subr 重写路径(FD 重映射+闭包收敛+重编号) + ("cid_nogsubr.bin", "n1", &["0", "1", "2", "5", "9", "20"]), + ("cid_nogsubr.bin", "n2", &["3", "7", "11"]), // 无 0 → 注入 .notdef + // name_fa:name-keyed 单 Private + 492 local subr 重写路径 + ("name_fa.bin", "f1", &["0", "1", "2", "3", "10", "100"]), + ("name_fa.bin", "f2", &["0", "700"]), + ("name_fa.bin", "f3", &["5", "42", "500"]), // 无 0 → 注入 .notdef + ]; + for (input, tag, gids) in cases { + let fixture_bytes = fixture(input); + let gid_str = gids.join(","); + let gid_list: Vec = gids.iter().map(|s| s.parse().unwrap()).collect(); + let rust_out = subset_cff(&fixture_bytes, &gid_list).expect("subset ok").expect("some"); + let n_expect = if gid_list[0] == 0 { gid_list.len() } else { gid_list.len() + 1 }; + check_structure(&rust_out, n_expect); + let zig_out = run_oracle(tag, input, &gid_str); + assert_eq!(rust_out, zig_out, "byte parity {input} gids={gid_str}"); + } + } + + /// 大 CID 字体(思源 NotoSansCJK SC 全量 65535 glyph、18 FD)对拍 + /// + /// 2026-11-03 正确性修复后与 Zig oracle 有意分歧:hintmask/cntrmask 栈上操作数是 + /// vstem 声明(OTS/FreeType 语义 num_stems += ss>>1),TS/Zig 三个版本的 + /// hintmask 掩码跳字节数均漏计这部分 stems,掩码漏跳 1 字节后把掩码字节误读成 + /// callsubr,流失步产生 OTS 拒收的损坏 charstring(Chrome: "Failed validating + /// CharStrings INDEX",浏览器拒收不渲染)。Rust 版修复后产物通过 OTS 校验 + /// (ots_sim.py 全字形 + Chrome 实测 LOADED),Zig 版产物仍为损坏形态。 + /// 此处断言的不再是字节一致,而是「分歧存在且 Rust 侧结构合法」。 + #[test] + fn parity_cid_full_noto() { + if !have(ORACLE) || !have(&format!("{FIXTURE_DIR}/cid_noto.bin")) { + eprintln!("skip: oracle/fixture 不存在"); + return; + } + let fixture_bytes = fixture("cid_noto.bin"); + // 3606:栈深峰值 49 > 48,覆盖 OTS 超限 → stripHints 剥 hint 分支 + let gids = ["0", "1", "5", "100", "2000", "30000", "3606", "65534"]; + let gid_list: Vec = gids.iter().map(|s| s.parse().unwrap()).collect(); + let rust_out = subset_cff(&fixture_bytes, &gid_list).expect("subset ok").expect("some"); + check_structure(&rust_out, gid_list.len()); + let zig_out = run_oracle("noto", "cid_noto.bin", &gids.join(",")); + assert_ne!(rust_out, zig_out, "hintmask stems 修复后应与损坏的 Zig 产物分歧"); + } +} diff --git a/rust-spike/src/glyph_match.rs b/rust-spike/src/glyph_match.rs new file mode 100644 index 0000000..613f1d4 --- /dev/null +++ b/rust-spike/src/glyph_match.rs @@ -0,0 +1,460 @@ +//! glyph-match 评分引擎:字形光栅化 + Chamfer 相似度(对译 zig-spike/src/glyph_match.zig, +//! 语义对齐 backend/font_util/glyph_bitmap.ts) +//! +//! 64x64 归一化网格:TrueType 二次曲线 4 段细分 → 非零环绕扫描线填充 → +//! 紧致 bbox 归一化(12% 留边);比对用 Chamfer 3-4 距离变换 + ±2px 平移搜索。 +//! 全 f64 光栅化(与 TS number 同精度),距离场 f32(与 Float32Array 同精度)。 + +use crate::ttf::{self, GlyfPt}; + +/// 归一化网格边长(与前端 segmenter.GRID 一致) +pub const GRID: usize = 64; +/// 归一化留边比例(与前端一致:12%) +const MARGIN_RATIO: f64 = 0.12; +/// 二次曲线细分段数(64 网格精度足够) +const MID_STEPS: usize = 4; + +/// 64x64 二值位图(0/1) +pub type BitmapT = [u8; GRID * GRID]; +/// 位图距离场 +pub type DtT = [f32; GRID * GRID]; + +/// 二维点(多边形顶点,y 已翻转) +#[derive(Clone, Copy)] +struct Pt { + x: f64, + y: f64, +} + +/// 生成位图(含 Chamfer 相似度)所需查询字形 +pub struct QueryGlyph { + /// 首个码点(TS codePointAt(0) 语义) + pub code_point: u32, + /// 64x64 二值位图(0/1) + pub bitmap: Box, + /// 位图距离场(解析后算一次,全库扫描复用) + pub dt: Box, + /// 查询序号(回传给前端对位) + pub query_index: usize, +} + +/// 查询字形原始输入(JSON 解析后的中间形态) +pub struct RawGlyph<'a> { + /// UTF-8 char 字段 + pub char: &'a [u8], + /// 4096 长度的 01 串 + pub bitmap: &'a [u8], + /// char 首码点(解码失败为 None,条目被过滤) + pub code_point: Option, +} + +/// 二次贝塞尔细分 MID_STEPS 段追加(不含起点,含终点) +fn quad(p0: Pt, pc: Pt, p1: Pt, poly: &mut Vec) { + for i in 1..=MID_STEPS { + let t = i as f64 / MID_STEPS as f64; + let mt = 1.0 - t; + poly.push(Pt { + x: mt * mt * p0.x + 2.0 * mt * t * pc.x + t * t * p1.x, + y: mt * mt * p0.y + 2.0 * mt * t * pc.y + t * t * p1.y, + }); + } +} + +/// 中点 +fn mid(a: Pt, b: Pt) -> Pt { + Pt { x: (a.x + b.x) / 2.0, y: (a.y + b.y) / 2.0 } +} + +/// 单条轮廓扁平化为多边形顶点序列(y 翻转 + 隐含中点 + 二次曲线细分) +fn flatten_contour(contour: &[GlyfPt]) -> Vec { + if contour.len() < 2 { + return Vec::new(); + } + let n = contour.len(); + // pts = y 翻转 + let pts: Vec = contour + .iter() + .map(|p| Pt { x: p.x as f64, y: -(p.y as f64) }) + .collect(); + + // 先找 on-curve 起点 + let start_idx = contour.iter().position(|p| p.on_curve); + let Some(si) = start_idx else { + // 全 off-curve(极罕见):首尾中点为隐含起点 + let start_pt = mid(pts[n - 1], pts[0]); + let mut poly = Vec::new(); + poly.push(start_pt); + for i in 0..n { + let cur = pts[i]; + let next = pts[(i + 1) % n]; + if contour[i].on_curve { + poly.push(cur); + } else { + let end = if contour[(i + 1) % n].on_curve { next } else { mid(cur, next) }; + quad(*poly.last().unwrap(), cur, end, &mut poly); + } + } + return poly; + }; + + // 正常路径:从 on-curve 起点绕一圈 + let mut poly = Vec::new(); + poly.push(pts[si]); + let mut prev_on = pts[si]; + for k in 1..=n { + let i = (si + k) % n; + let cur = pts[i]; + if contour[i].on_curve { + poly.push(cur); + prev_on = cur; + } else { + let next_idx = (i + 1) % n; + let end = if contour[next_idx].on_curve { pts[next_idx] } else { mid(cur, pts[next_idx]) }; + quad(prev_on, cur, end, &mut poly); + // off-curve 段结束后的隐含 on-curve 点也要成为下一段的起点 + poly.push(end); + prev_on = end; + } + } + poly +} + +/// 紧致 bbox 归一化多边形到 64x64 内框(12% 留边,与前端 maskToNormalizedRGBA 同参) +fn normalize_polys(polys: &[Vec]) -> Vec> { + let mut min_x = f64::INFINITY; + let mut min_y = f64::INFINITY; + let mut max_x = f64::NEG_INFINITY; + let mut max_y = f64::NEG_INFINITY; + for poly in polys { + for p in poly { + if p.x < min_x { + min_x = p.x; + } + if p.x > max_x { + max_x = p.x; + } + if p.y < min_y { + min_y = p.y; + } + if p.y > max_y { + max_y = p.y; + } + } + } + let w = max_x - min_x; + let h = max_y - min_y; + // 退化(空轮廓/纯水平线)保护 + if !(w > 0.0) || !(h > 0.0) { + return Vec::new(); + } + + let margin = GRID as f64 * MARGIN_RATIO; + let inner = GRID as f64 - margin * 2.0; + let scale = (inner / w).min(inner / h); + let dw = w * scale; + let dh = h * scale; + let ox = (GRID as f64 - dw) / 2.0 - min_x * scale; + let oy = (GRID as f64 - dh) / 2.0 - min_y * scale; + polys + .iter() + .map(|poly| { + poly.iter() + .map(|p| Pt { x: p.x * scale + ox, y: p.y * scale + oy }) + .collect() + }) + .collect() +} + +/// 交点(x 坐标 + 环绕方向) +struct Crossing { + x: f64, + winding: i32, +} + +/// 扫描线按非零环绕规则填充多边形集合(必须合并全部轮廓的交点,保留封闭留白) +fn scanline_fill(polys: &[Vec]) -> BitmapT { + let mut grid: BitmapT = [0; GRID * GRID]; + let mut crossings: Vec = Vec::new(); + for y in 0..GRID { + let sy = y as f64 + 0.5; + crossings.clear(); + for poly in polys { + if poly.len() < 3 { + continue; + } + for (i, a) in poly.iter().enumerate() { + let b = poly[(i + 1) % poly.len()]; + if a.y == b.y { + continue; + } + if (sy >= a.y && sy < b.y) || (sy >= b.y && sy < a.y) { + crossings.push(Crossing { + x: a.x + ((sy - a.y) / (b.y - a.y)) * (b.x - a.x), + winding: if a.y < b.y { 1 } else { -1 }, + }); + } + } + } + // 按 x 升序(稳定排序,对齐 Zig std.mem.sort) + crossings.sort_by(|a, b| a.x.partial_cmp(&b.x).unwrap_or(std::cmp::Ordering::Equal)); + let mut winding: i32 = 0; + for i in 0..crossings.len().saturating_sub(1) { + winding += crossings[i].winding; + if winding == 0 { + continue; + } + // 对齐 Zig:x0 只向下钳 0、x1 只向上钳 GRID-1,越出网格的方向不钳 + // (x0 > x1 时循环自然不执行),避免右边缘多填一格 + let x0 = ((crossings[i].x - 0.5).ceil() as i64).max(0); + let x1 = ((crossings[i + 1].x - 0.5).floor() as i64).min(GRID as i64 - 1); + let mut x = x0; + while x <= x1 { + grid[y * GRID + x as usize] = 1; + x += 1; + } + } + } + grid +} + +/// 距离变换(Chamfer 3-4 两遍扫描):每个 0 像素到最近 1 像素的距离 +pub fn distance_transform(mask: &[u8], dt: &mut DtT) { + const INF: f32 = 1e9; + for i in 0..dt.len() { + dt[i] = if mask[i] != 0 { 0.0 } else { INF }; + } + // 正向扫描(左上 → 右下) + for y in 0..GRID { + for x in 0..GRID { + let i = y * GRID + x; + let mut v = dt[i]; + if x > 0 { + v = v.min(dt[i - 1] + 3.0); + } + if y > 0 { + v = v.min(dt[i - GRID] + 3.0); + } + if x > 0 && y > 0 { + v = v.min(dt[i - GRID - 1] + 4.0); + } + if x < GRID - 1 && y > 0 { + v = v.min(dt[i - GRID + 1] + 4.0); + } + dt[i] = v; + } + } + // 反向扫描(右下 → 左上) + let mut y = GRID - 1; + loop { + let mut x = GRID - 1; + loop { + let i = y * GRID + x; + let mut v = dt[i]; + if x < GRID - 1 { + v = v.min(dt[i + 1] + 3.0); + } + if y < GRID - 1 { + v = v.min(dt[i + GRID] + 3.0); + } + if x < GRID - 1 && y < GRID - 1 { + v = v.min(dt[i + GRID + 1] + 4.0); + } + if x > 0 && y < GRID - 1 { + v = v.min(dt[i + GRID - 1] + 4.0); + } + dt[i] = v; + if x == 0 { + break; + } + x -= 1; + } + if y == 0 { + break; + } + y -= 1; + } +} + +/// a 的笔画像素在 dt_b 距离场上的平均距离(越近越像);空掩码返回 -1 +fn mean_distance(a: &[u8], dt_b: &[f32], dx: i64, dy: i64) -> f64 { + let mut sum: f64 = 0.0; + let mut count: u32 = 0; + for y in 0..GRID { + let sy = y as i64 + dy; + if sy < 0 || sy >= GRID as i64 { + continue; + } + for x in 0..GRID { + if a[y * GRID + x] == 0 { + continue; + } + let sx = x as i64 + dx; + if sx < 0 || sx >= GRID as i64 { + continue; + } + sum += dt_b[(sy * GRID as i64 + sx) as usize] as f64; + count += 1; + } + } + if count == 0 { + return -1.0; + } + sum / count as f64 / 3.0 // 除以 3 归一到像素单位 +} + +/// 容错字形相似度 —— 对称 Chamfer 距离 + ±2px 平移搜索,score = exp(-worst/σ),σ=4px +pub fn glyph_similarity(a: &[u8], b: &[u8], dt_a: &[f32], dt_b: &[f32]) -> f64 { + let mut worst = f64::INFINITY; + for dy in -2i64..=2 { + for dx in -2i64..=2 { + let d_ab = mean_distance(a, dt_b, dx, dy); + let d_ba = mean_distance(b, dt_a, -dx, -dy); + if d_ab < 0.0 || d_ba < 0.0 { + continue; + } + let m = d_ab.max(d_ba); + if m < worst { + worst = m; + } + } + } + if !worst.is_finite() { + return 0.0; + } + (-worst / 4.0).exp() +} + +/// 从已解析字体取指定码点的归一化位图;缺字/空轮廓/全空位图返回 None(语义对齐 getGlyphBitmap) +pub fn get_glyph_bitmap(font: &ttf::Font, code_point: u32) -> Option> { + let gid = font.glyph_id(code_point)?; + let Ok(contours) = ttf::glyph_contours(font, gid, 0) else { + return None; + }; + if contours.is_empty() { + return None; + } + let mut polys: Vec> = Vec::new(); + for c in &contours { + let poly = flatten_contour(c); + if poly.len() >= 3 { + polys.push(poly); + } + } + let normalized = normalize_polys(&polys); + if normalized.is_empty() { + return None; + } + let bitmap: Box = Box::new(scanline_fill(&normalized)); + // 全空位图视为缺字 + if bitmap.iter().all(|&v| v == 0) { + return None; + } + Some(bitmap) +} + +/// 解析查询字形列表:01 串 → 位图 + 距离场;非法位图/空 char 的条目被过滤(语义对齐 handler 过滤) +pub fn parse_query_glyphs(raw: &[RawGlyph<'_>]) -> Vec { + let mut out: Vec = Vec::new(); + for (query_index, rg) in raw.iter().enumerate() { + if rg.bitmap.len() != GRID * GRID { + continue; + } + let mut bm: Box = Box::new([0; GRID * GRID]); + let mut valid = true; + for (i, &c) in rg.bitmap.iter().enumerate() { + if c != b'0' && c != b'1' { + valid = false; + break; + } + bm[i] = c - b'0'; + } + if !valid { + continue; + } + let Some(code_point) = rg.code_point else { continue }; + let mut dt: Box = Box::new([0.0; GRID * GRID]); + distance_transform(&bm[..], &mut dt); + out.push(QueryGlyph { code_point, bitmap: bm, dt, query_index }); + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn distance_transform_zero_mask_is_all_inf() { + let mask = [0u8; GRID * GRID]; + let mut dt: DtT = [0.0; GRID * GRID]; + distance_transform(&mask, &mut dt); + assert!(dt.iter().all(|&v| v == 1e9)); + } + + #[test] + fn distance_transform_center_dot() { + let mut mask = [0u8; GRID * GRID]; + mask[32 * GRID + 32] = 1; + let mut dt: DtT = [0.0; GRID * GRID]; + distance_transform(&mask, &mut dt); + assert_eq!(dt[32 * GRID + 32], 0.0); + // 相邻 0 像素距离 3(Chamfer 3-4) + assert_eq!(dt[32 * GRID + 31], 3.0); + // 对角像素距离 4 + assert_eq!(dt[31 * GRID + 31], 4.0); + } + + #[test] + fn similarity_self_is_one() { + let mut mask = [0u8; GRID * GRID]; + for y in 20..44 { + for x in 20..44 { + mask[y * GRID + x] = 1; + } + } + let mut dt: DtT = [0.0; GRID * GRID]; + distance_transform(&mask, &mut dt); + let s = glyph_similarity(&mask, &mask, &dt, &dt); + assert!((s - 1.0).abs() < 1e-12); + } + + #[test] + fn empty_similarity_is_zero() { + let mask = [0u8; GRID * GRID]; + let mut dt: DtT = [0.0; GRID * GRID]; + distance_transform(&mask, &mut dt); + assert_eq!(glyph_similarity(&mask, &mask, &dt, &dt), 0.0); + } + + #[test] + fn parse_query_glyphs_filters_invalid() { + let raw = [ + RawGlyph { char: b"a", bitmap: &[b'0'; 4096], code_point: Some(97) }, + RawGlyph { char: b"b", bitmap: &[b'0'; 100], code_point: Some(98) }, // 长度不足 + RawGlyph { char: b"c", bitmap: &[b'2'; 4096], code_point: Some(99) }, // 非法字符 + RawGlyph { char: b"d", bitmap: &[b'1'; 4096], code_point: None }, // 无码点 + ]; + let out = parse_query_glyphs(&raw); + assert_eq!(out.len(), 1); + assert_eq!(out[0].query_index, 0); + assert_eq!(out[0].code_point, 97); + } + + #[test] + fn scanline_fill_rectangle() { + // 一个填满 [10,54)x[10,54) 的正方形(顶点在整数网格上,扫描线 y+0.5 命中内部) + let poly = vec![ + Pt { x: 10.0, y: 10.0 }, + Pt { x: 54.0, y: 10.0 }, + Pt { x: 54.0, y: 54.0 }, + Pt { x: 10.0, y: 54.0 }, + ]; + let grid = scanline_fill(&[poly]); + assert_eq!(grid[30 * GRID + 30], 1); + // 交点恰在 x=10:x0=ceil(10-0.5)=10,右界 x1=floor(54-0.5)=53(不含 54) + assert_eq!(grid[10 * GRID + 10], 1); + assert_eq!(grid[10 * GRID + 54], 0); + assert_eq!(grid[9 * GRID + 30], 0); // y<10 行未命中 + assert_eq!(grid[54 * GRID + 30], 0); // y>=54 行未命中 + } +} diff --git a/rust-spike/src/gsub.rs b/rust-spike/src/gsub.rs new file mode 100644 index 0000000..101c360 --- /dev/null +++ b/rust-spike/src/gsub.rs @@ -0,0 +1,3214 @@ +//! GSUB 可达收集 + 表子集化(对译 zig-spike/src/gsub.zig) +//! +//! 移植语义说明: +//! - 逐行对译 Zig 版(含其全部性能优化语义:covCache 跨路径共享、二分、反转遍历),不做等价简化—— +//! 反转遍历路径(coverage 远大于 reachable 时遍历 reachable 二分 coverage)在可达侧决定 target +//! 发现顺序即插入序,必须保留;子集化侧的反转路径仅影响性能(entries 排序后字节不变),同样保留 +//! 以便肉眼逐段对查。 +//! - subsetGSUB 保留全部影响输出字节的语义:emitCoverage format 判据(rangeCount*6 < n*2)、 +//! entries 按 from 升序排序、readCoverageRemapped 结果升序 + 全子集外判 null、 +//! allEmpty lookup 折叠 subCount=1、skipable 子表跳过、失败降级空 subtable、 +//! ScriptList/FeatureList 连续块快路径(span 不越过下一 list 边界)。 +//! - collect_reachable 返回「插入序」而非升序:TS 的 Set 迭代序 = subsetGids 追加顺序 = +//! 新 gid 编号,与 TS 引擎 glyph 顺序对拍的前提(fonteditor subsetGids 不排序)。 +//! - Zig GsubError = error{OutOfMemory}:Rust 分配失败默认直接 abort,运行时不会产生 Err; +//! Err 仅为接口契约保留(解析失败走 sentinel:null/false/-1,与 Zig 一致)。 +//! - Reader 的越界标志用 Cell 内部可变性:Zig 的 *Reader 可变指针在 Rust 侧改为共享引用, +//! 使 SubCtx 能与调用方并发只读持有同一 Reader(error_flag 读写语义不变)。 +//! - Zig AutoHashMap 迭代序不可预测但「结果不可观察」:所有 map 消费点都先按 gid 升序排序 +//! (writeClassDefFromMap / emitClassDefFromClassMap)或为单射查值(PairPos fmt2 紧致重编号, +//! Rust 侧直接用升序 used 数组按下标取原 class,与 Zig 迭代反查 value==nc 的结果一致), +//! 输出字节确定。 + +use std::cell::Cell; +use std::collections::HashMap; + +/// Coverage format1/2 展开的单 range 上限保护:超出视为偏移错位读到垃圾数据(与 TS COVERAGE_MAX_EXPAND 一致) +const COVERAGE_MAX_EXPAND: usize = 0x10000; + +/// GSUB/GPOS 处理错误(对译 Zig GsubError = error{OutOfMemory}) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum GsubError { + /// 内存分配失败(Rust 分配失败默认 abort,运行时不会产生;仅为接口契约保留) + #[allow(dead_code)] // Zig error set {OutOfMemory} 的契约成员;Rust 分配失败直接 abort 不经此路径 + OutOfMemory, +} + +/// 大端序读取器(越界置 error_flag 返回 0,与 TS OTReader 一致) +struct Reader<'a> { + data: &'a [u8], + /// 越界标志(Cell:rd16/rd32 以 &self 置位,SubCtx 共享持有) + error_flag: Cell, +} + +impl<'a> Reader<'a> { + fn new(data: &'a [u8]) -> Reader<'a> { + Reader { data, error_flag: Cell::new(false) } + } + + /// 带边界检查的 u16 读取(对应 TS r.u16,越界置 error_flag) + fn rd16(&self, off: usize) -> u16 { + if off + 2 > self.data.len() { + self.error_flag.set(true); + return 0; + } + u16::from_be_bytes([self.data[off], self.data[off + 1]]) + } + + /// 带边界检查的 i16 读取(对应 TS r.i16) + fn rd16s(&self, off: usize) -> i16 { + if off + 2 > self.data.len() { + self.error_flag.set(true); + return 0; + } + i16::from_be_bytes([self.data[off], self.data[off + 1]]) + } + + /// 带边界检查的 u32 读取(对应 TS r.u32) + fn rd32(&self, off: usize) -> u32 { + if off + 4 > self.data.len() { + self.error_flag.set(true); + return 0; + } + u32::from_be_bytes([self.data[off], self.data[off + 1], self.data[off + 2], self.data[off + 3]]) + } + + /// 无 error_flag 的 u16 读取(对应 TS 侧 dv.getUint16 直读;TS 越界会 throw, + /// 这里按 0 处理,仅损坏表触达,合法字体两者一致) + fn raw16(&self, off: usize) -> u16 { + if off + 2 > self.data.len() { + return 0; + } + u16::from_be_bytes([self.data[off], self.data[off + 1]]) + } + + fn clear_error(&self) { + self.error_flag.set(false); + } +} + +/// 大端序字节写入器(偏移槽手工占位 + w16at 回填,替代 TS reserveOffset16 闭包模式,输出字节相同) +struct Writer { + list: Vec, +} + +impl Writer { + fn new() -> Writer { + Writer { list: Vec::new() } + } + + /// 按上界预分配容量(对齐 Zig OTWriter 预分配经验:消除写 U16 的反复扩容 memcpy) + fn with_capacity(cap: usize) -> Writer { + Writer { list: Vec::with_capacity(cap) } + } + + fn len(&self) -> usize { + self.list.len() + } + + fn w16(&mut self, v: u16) { + self.list.extend_from_slice(&v.to_be_bytes()); + } + + /// 在已写入范围内回填 u16(对应 TS writeInt16At,仅覆盖不扩展) + fn w16at(&mut self, pos: usize, v: u16) { + self.list[pos..pos + 2].copy_from_slice(&v.to_be_bytes()); + } + + fn wbytes(&mut self, s: &[u8]) { + self.list.extend_from_slice(s); + } + + /// 回退到指定位置(对应 TS rollback;本实现无 patches,直接截断即可) + fn rollback(&mut self, pos: usize) { + self.list.truncate(pos); + } +} + +/// 插入序 gid 集合(对应 TS Set 的 迭代序=插入序 语义)。 +/// 位图替代 HashSet:u16 键走 SipHash 纯开销;按需增长避免定长数组的全量 memset +///(Zig 版 Set→Uint8 负优化的根因),clear 只清触碰过的前缀 +#[derive(Default)] +struct OrderedGidSet { + items: Vec, + /// gid→bit 位图(gid/64 单调增长, doubling 由 Vec::resize 承担) + bits: Vec, + /// 本次 clear 需要重置的前缀长度(= 曾达到的最大 bits.len()) + words_used: usize, +} + +impl OrderedGidSet { + /// 不存在则追加(返回是否新增) + fn add(&mut self, gid: u16) -> bool { + let w = (gid >> 6) as usize; + if w >= self.bits.len() { + self.bits.resize(w + 1, 0); + self.words_used = self.words_used.max(self.bits.len()); + } + let bit = 1u64 << (gid & 63); + if self.bits[w] & bit != 0 { + return false; + } + self.bits[w] |= bit; + self.items.push(gid); + true + } + + fn contains(&self, gid: u16) -> bool { + let w = (gid >> 6) as usize; + w < self.bits.len() && self.bits[w] & (1u64 << (gid & 63)) != 0 + } + + fn count(&self) -> usize { + self.items.len() + } + + fn clear(&mut self) { + self.items.clear(); + for word in &mut self.bits[..self.words_used] { + *word = 0; + } + self.words_used = 0; + } +} + +/// covCache 单条目(对应 TS CoverageCache entry) +/// gids 非空(Some)= 曾被 cov_gids_cached(fmt1 路径)以「原始 gid 序」填充; +/// gids 为 None = read_coverage_remapped 首算条目(只存升序 remapped)。 +/// 两态共存(先 remapped 后 gids 回填)时 gids 优先参与后续判定(与 TS 一致)。 +#[derive(Default)] +struct CovEntry { + /// 原始 gid 列表(原始顺序);None = 未被 gids 侧填充(等价 TS EMPTY_GIDS 占位) + gids: Option>, + /// 重映射后新 gid(首次计算为升序;gids 命中回填为原序——TS 命中分支不排序) + remapped: Option>, + /// 「原非空但全子集外」失效标记(remapped=None 语义) + out_of_subset: bool, +} + +/// 原 gid → 新 gid 查找上下文(对应 TS GidLookup Int32Array + 模块级 currentSortedSubsetGids) +struct SubCtx<'a> { + r: &'a Reader<'a>, + /// 下标=原 gid,值=新 gid,-1=不在子集;容量=最大子集原 gid+1(与 TS buildGidLookup 一致, + /// 越界 gid 按 -1 处理) + gid_lookup: Vec, + /// 子集原始 gid 升序数组(coverage format2 / ClassDef format2 二分用) + sorted_subset: Vec, + /// covCache:key=coverage 表绝对偏移。字节级对拍要求复刻 TS 的跨路径共享语义: + /// chain fmt1 经 cov_gids_cached 填原始 gids 后,同 off 的 fmt3/ClassDef 重映射命中走 + /// 「原序重映射、不排序」分支(TS readCoverageRemapped hit 分支)。 + cov_cache: HashMap, +} + +impl<'a> SubCtx<'a> { + /// 重映射单个原 gid:不在子集(或越界)返回 None + fn remap(&self, gid: u32) -> Option { + let g = gid as usize; + if g >= self.gid_lookup.len() { + return None; + } + let m = self.gid_lookup[g]; + if m < 0 { + return None; + } + Some(m as u16) + } +} + +// ===== Coverage 解析(gsub-subset.ts / gsub-reachable.ts 共用语义)===== + +/// 读取 Coverage 表的原始 gid 列表(对应 TS readCoverageGids,无缓存)。 +/// format2 带 COVERAGE_MAX_EXPAND 保护(损坏 range 停止展开,返回已收集部分)。 +fn read_coverage_gids(r: &Reader, off: usize) -> Vec { + let mut gids: Vec = Vec::new(); + if off + 4 > r.data.len() { + return gids; + } + let format = r.raw16(off); + if format == 1 { + let count = r.raw16(off + 2) as usize; + let base = off + 4; + if base + count * 2 > r.data.len() { + return gids; + } + for i in 0..count { + gids.push(r.raw16(base + i * 2)); + } + } else if format == 2 { + let range_count = r.raw16(off + 2) as usize; + let mut p = off + 4; + for _ in 0..range_count { + if p + 6 > r.data.len() { + break; + } + let start = r.raw16(p); + let end = r.raw16(p + 2); + if end >= start + && ((end - start) as usize) < COVERAGE_MAX_EXPAND + && gids.len() + ((end - start + 1) as usize) <= COVERAGE_MAX_EXPAND + { + let mut g = start; + loop { + gids.push(g); + if g == end { + break; + } + g += 1; + } + } + p += 6; + } + } + gids +} + +/// coverage 中第一个不在集合内的 gid;全在集合内(或 format 未知)返回 None +fn coverage_first_excluded_gid(r: &Reader, off: usize, in_set: &OrderedGidSet) -> Option { + if off + 4 > r.data.len() { + return None; + } + let format = r.raw16(off); + if format == 1 { + let count = r.raw16(off + 2) as usize; + let base = off + 4; + for i in 0..count { + let g = r.raw16(base + i * 2); + if !in_set.contains(g) { + return Some(g); + } + } + None + } else if format == 2 { + let range_count = r.raw16(off + 2) as usize; + let mut p = off + 4; + for _ in 0..range_count { + let start = r.raw16(p); + let end = r.raw16(p + 2); + let mut g = start; + loop { + if !in_set.contains(g) { + return Some(g); + } + if g == end { + break; + } + // wrapping_add:损坏 coverage(start>end)时对齐 Zig ReleaseFast 环绕语义不 panic + g = g.wrapping_add(1); + } + p += 6; + } + None + } else { + None + } +} + +/// coverage 中二分查找 gid 的序号(0-based);不在返回 -1(对应 TS coverageIndexOf) +fn coverage_index_of(r: &Reader, off: usize, gid: u16) -> i64 { + if off + 4 > r.data.len() { + return -1; + } + let format = r.raw16(off); + if format == 1 { + let count = r.raw16(off + 2) as usize; + let base = off + 4; + let mut lo: usize = 0; + let mut hi: usize = count; + while lo < hi { + let mid = (lo + hi) >> 1; + let mg = r.raw16(base + mid * 2); + if mg < gid { + lo = mid + 1; + } else if mg > gid { + hi = mid; + } else { + return mid as i64; + } + } + -1 + } else if format == 2 { + let range_count = r.raw16(off + 2) as usize; + let base = off + 4; + // 二分找第一个 end >= gid 的 range(range 按 start 升序,end 亦升序) + let mut lo: usize = 0; + let mut hi: usize = range_count; + while lo < hi { + let mid = (lo + hi) >> 1; + let end = r.raw16(base + mid * 6 + 2); + if end < gid { + lo = mid + 1; + } else { + hi = mid; + } + } + if lo >= range_count { + return -1; + } + let range_off = base + lo * 6; + let start = r.raw16(range_off); + let end = r.raw16(range_off + 2); + if gid < start || gid > end { + return -1; + } + let mut prefix: u32 = 0; + for i in 0..lo { + let s = r.raw16(base + i * 6); + let e = r.raw16(base + i * 6 + 2); + prefix += u32::from(e) - u32::from(s) + 1; + } + (prefix + (gid - start) as u32) as i64 + } else { + -1 + } +} + +/// coverage 的 gid 总数,不展开数组(对应 TS coverageCount) +fn coverage_count(r: &Reader, off: usize) -> usize { + if off + 4 > r.data.len() { + return 0; + } + let format = r.raw16(off); + if format == 1 { + return r.raw16(off + 2) as usize; + } + if format == 2 { + let range_count = r.raw16(off + 2) as usize; + let base = off + 4; + let mut total: usize = 0; + for i in 0..range_count { + let s = r.raw16(base + i * 6); + let e = r.raw16(base + i * 6 + 2); + if e >= s { + total += e as usize - s as usize + 1; + } + } + return total; + } + 0 +} + +/// 判定 coverage 是否「原非空且全部 gid 落子集外」(对应 TS coverageAllOutOfSubset) +fn coverage_all_out_of_subset(ctx: &SubCtx, cov_off: usize) -> bool { + let r = ctx.r; + if cov_off + 4 > r.data.len() { + return false; + } + let format = r.raw16(cov_off); + if format == 1 { + let count = r.raw16(cov_off + 2) as usize; + if count == 0 { + return false; // 原 coverage 本就空 + } + let base = cov_off + 4; + if base + count * 2 > r.data.len() { + return false; + } + for i in 0..count { + if ctx.remap(u32::from(r.raw16(base + i * 2))).is_some() { + return false; + } + } + return true; + } + if format == 2 { + let range_count = r.raw16(cov_off + 2) as usize; + let sorted = &ctx.sorted_subset; + let sn = sorted.len(); + let mut p = cov_off + 4; + let mut orig_non_empty = false; + for _ in 0..range_count { + if p + 6 > r.data.len() { + break; + } + let start = r.raw16(p); + let end = r.raw16(p + 2); + if end >= start && ((end - start) as usize) < COVERAGE_MAX_EXPAND { + orig_non_empty = true; + // 二分判定 range 是否含任一子集 gid + if sn > 0 && start <= sorted[sn - 1] && end >= sorted[0] { + let mut lo: usize = 0; + let mut hi: usize = sn; + while lo < hi { + let mid = (lo + hi) >> 1; + if sorted[mid] < start { + lo = mid + 1; + } else { + hi = mid; + } + } + if lo < sn && sorted[lo] <= end { + return false; + } + } + } + p += 6; + } + return orig_non_empty; + } + false +} + +/// 读取 coverage 原始 gid 并写入缓存(对应 TS readCoverageGids 带 covCache 的调用方, +/// subset 侧仅 chain fmt1 使用)。命中 gids 条目直接返回;否则现场解析后合并进缓存 +/// (保留可能已存在的 remapped/out_of_subset 字段,TS mergeGidsEntry 语义)。 +/// Rust 侧返回拷贝(Zig 返回存于缓存的切片,调用方不得释放——拷贝不改变语义)。 +fn cov_gids_cached(ctx: &mut SubCtx, off: usize) -> Vec { + if let Some(entry) = ctx.cov_cache.get(&off) { + if let Some(g) = &entry.gids { + return g.clone(); + } + } + let gids = read_coverage_gids(ctx.r, off); + if let Some(entry) = ctx.cov_cache.get_mut(&off) { + // 已有 remapped 条目:保留 remapped/out_of_subset,仅回填 gids + entry.gids = Some(gids.clone()); + } else { + ctx.cov_cache.insert(off, CovEntry { gids: Some(gids.clone()), ..Default::default() }); + } + gids +} + +/// 读取 coverage 并返回重映射后的新 gid 列表;原非空但全子集外返回 None +/// (对应 TS readCoverageRemapped 带缓存版:首算升序排序并缓存; +/// 命中「gids 先填」条目时按原序现场重映射、不排序——字节级对拍依赖该差异) +fn read_coverage_remapped(ctx: &mut SubCtx, off: usize) -> Option> { + if let Some(entry) = ctx.cov_cache.get(&off) { + if let Some(ogids) = entry.gids.clone() { + // TS 命中分支:从已缓存的原始 gids 现场重映射,保持原序、不排序 + let mut m: Vec = Vec::with_capacity(ogids.len()); + for &g in &ogids { + if let Some(ng) = ctx.remap(u32::from(g)) { + m.push(ng); + } + } + let oos = m.is_empty() && !ogids.is_empty(); + let e = ctx.cov_cache.get_mut(&off).expect("entry just checked"); + e.remapped = Some(m.clone()); + e.out_of_subset = oos; + return if oos { None } else { Some(m) }; + } + return if entry.out_of_subset { None } else { entry.remapped.clone() }; + } + let r = ctx.r; + let mut new_gids: Vec = Vec::new(); + let mut orig_non_empty = false; + if off + 4 > r.data.len() { + // 越界,按空 coverage 处理(TS 语义:newGids 空、origNonEmpty=false → 返回空数组) + } else { + let format = r.raw16(off); + if format == 1 { + let count = r.raw16(off + 2) as usize; + let base = off + 4; + if base + count * 2 > r.data.len() { + // 数据越界:不进循环,origNonEmpty 保持 false + } else if count > ctx.gid_lookup.len() { + // 损坏 coverage(count 超过 glyph 总数):跳过必然全空的循环, + // 仅保留 origNonEmpty=count>0 语义 → 全空 → outOfSubset → None + orig_non_empty = count > 0; + } else { + orig_non_empty = count > 0; + for i in 0..count { + if let Some(ng) = ctx.remap(u32::from(r.raw16(base + i * 2))) { + new_gids.push(ng); + } + } + } + } else if format == 2 { + let range_count = r.raw16(off + 2) as usize; + let num_glyphs = ctx.gid_lookup.len(); + let sorted = &ctx.sorted_subset; + let sn = sorted.len(); + let mut p = off + 4; + for _ in 0..range_count { + if p + 6 > r.data.len() { + break; + } + let start = r.raw16(p); + let end = r.raw16(p + 2); + if end >= start + && ((end - start) as usize) < COVERAGE_MAX_EXPAND + && new_gids.len() + ((end - start + 1) as usize) <= COVERAGE_MAX_EXPAND + { + if (start as usize) >= num_glyphs { + orig_non_empty = true; + } else if sn > 0 { + // @intCast(num_glyphs-1):num_glyphs = gid_lookup.len ≥ 1(subsetGSUB 恒非空表) + let e: u16 = if (end as usize) < num_glyphs { end } else { (num_glyphs - 1) as u16 }; + orig_non_empty = true; + if !(e < sorted[0] || start > sorted[sn - 1]) { + // 二分定位第一个 >= start 的子集 gid,顺序扫描到 > e 为止 + let mut lo: usize = 0; + let mut hi: usize = sn; + while lo < hi { + let mid = (lo + hi) >> 1; + if sorted[mid] < start { + lo = mid + 1; + } else { + hi = mid; + } + } + let mut j = lo; + while j < sn { + let g = sorted[j]; + if g > e { + break; + } + // @intCast(i32→u16):sorted 中的 gid 必在子集内,映射值 ≥ 0 + new_gids.push(ctx.gid_lookup[g as usize] as u16); + j += 1; + } + } + } else { + orig_non_empty = true; + } + } + p += 6; + } + } + } + if new_gids.is_empty() && orig_non_empty { + return None; + } + // 缓存入口统一升序排序(原 coverage 升序但 原 gid→新 gid 映射不保序;emitCoverage 假定升序输入) + if new_gids.len() > 1 { + new_gids.sort_unstable(); + } + ctx.cov_cache + .insert(off, CovEntry { remapped: Some(new_gids.clone()), ..Default::default() }); + Some(new_gids) +} + +// ===== GSUB lookup 结构解析(reachable 与 subset 共用)===== + +/// 解析后的单个 lookup(effectiveType 已解包 Extension) +struct Lookup { + effective_type: i32, + sub_offs: Vec, + /// 原始 lookup 表头绝对偏移(subsetGSUB 读 lookupFlag / markFilteringSet 用;可达侧不用) + orig_off: usize, +} + +/// 解析 LookupList:每 lookup 的 effectiveType 与 subtable 绝对偏移。 +/// Extension(type7) 解引用:内嵌 type/subtableOffset 指向内嵌 subtable。 +fn parse_lookups(r: &Reader, lookup_list_off: usize) -> Vec { + let lookup_count = r.rd16(lookup_list_off) as usize; + let mut lookups: Vec = Vec::new(); + for i in 0..lookup_count { + let l_off = lookup_list_off + r.raw16(lookup_list_off + 2 + i * 2) as usize; + let lookup_type = r.raw16(l_off) as usize; + let sub_table_count = r.raw16(l_off + 4) as usize; + let mut sub_offs: Vec = Vec::new(); + let mut effective_type: i32 = lookup_type as i32; + for j in 0..sub_table_count { + let sub_off = l_off + r.raw16(l_off + 6 + j * 2) as usize; + if lookup_type == 7 { + // ExtensionSubst format1:ExtensionFormat(=1) + ExtensionLookupType + ExtensionOffset(u32) + if r.raw16(sub_off) != 1 { + effective_type = -1; + continue; + } + effective_type = i32::from(r.raw16(sub_off + 2)); + sub_offs.push(sub_off + r.rd32(sub_off + 4) as usize); + } else { + sub_offs.push(sub_off); + } + } + lookups.push(Lookup { effective_type, sub_offs, orig_off: l_off }); + } + lookups +} + +// ===== 可达收集(gsub-reachable.ts)===== + +/// 从 seed gids 出发、经 GSUB 替换链可达的全部 gid(含 seed;固定点迭代)。 +/// 返回「插入序」数组(TS Set 迭代序语义,决定 TS subsetGids 追加顺序/新 gid 编号)。 +/// 版本不支持时返回空 Vec(≠ 错误,调用方退 seed 序)。 +pub fn collect_reachable(gsub_bytes: &[u8], seed_gids: &[u16]) -> Result, GsubError> { + let r = Reader::new(gsub_bytes); + let major = r.rd16(0); + let minor = r.rd16(2); + if major != 1 || minor > 1 { + return Ok(Vec::new()); + } + let lookup_list_off = r.rd16(8) as usize; + let lookups = parse_lookups(&r, lookup_list_off); + + let mut reachable = OrderedGidSet::default(); + for &g in seed_gids { + reachable.add(g); + } + + // 固定点迭代(与 TS 循环结构逐句对应;TS 的 settledChain/failGidMap 记忆层不影响 + // 结果集合与插入顺序,故省略——失败状态下扫描该 subtable 不产任何 target/ctxGid) + let mut ctx_gids = OrderedGidSet::default(); + let mut refs = OrderedGidSet::default(); + let mut changed = true; + while changed { + changed = false; + for lk in &lookups { + for &sub_abs in &lk.sub_offs { + if lk.effective_type == 6 { + // type6 ChainedContext:收集可触发规则引用的 lookup index 与所需 context gid + ctx_gids.clear(); + refs.clear(); + collect_chain_refs(&r, sub_abs, &mut refs, &mut ctx_gids, &reachable); + for &g in &ctx_gids.items { + if reachable.add(g) { + changed = true; + } + } + for &li in &refs.items { + let li = li as usize; + if li >= lookups.len() { + continue; + } + let ref_lk = &lookups[li]; + for &ref_sub in &ref_lk.sub_offs { + let ref_targets = + collect_subtable_targets(&r, ref_sub, ref_lk.effective_type, &reachable); + for g in ref_targets { + if reachable.add(g) { + changed = true; + } + } + } + } + } else { + let new_targets = collect_subtable_targets(&r, sub_abs, lk.effective_type, &reachable); + for g in new_targets { + if reachable.add(g) { + changed = true; + } + } + } + } + } + if r.error_flag.get() { + break; + } + } + Ok(reachable.items) +} + +/// 从单个 subtable 收集 target gid(type1/2/3/4);type6 不直接产生 target(经 chainRefs 间接) +fn collect_subtable_targets(r: &Reader, off: usize, lookup_type: i32, reachable: &OrderedGidSet) -> Vec { + let mut targets: Vec = Vec::new(); + if lookup_type == 1 { + // SingleSubst: format1 coverage+delta / format2 coverage+gidArray + let format = r.rd16(off); + let cov_off = off + r.rd16(off + 2) as usize; + if format == 1 { + let delta = r.rd16s(off + 4); + if coverage_count(r, cov_off) > reachable.count() { + // 反转路径(大 coverage):遍历 reachable 二分 coverage(决定插入序,必须保留) + for &g in &reachable.items { + if coverage_index_of(r, cov_off, g) >= 0 { + targets.push(g.wrapping_add(delta as u16)); + } + } + } else { + let cov_gids = read_coverage_gids(r, cov_off); + for g in cov_gids { + if reachable.contains(g) { + targets.push(g.wrapping_add(delta as u16)); + } + } + } + } else if format == 2 { + let count = r.rd16(off + 4) as usize; + if coverage_count(r, cov_off) > reachable.count() { + for &g in &reachable.items { + let idx = coverage_index_of(r, cov_off, g); + if idx >= 0 && (idx as usize) < count { + targets.push(r.raw16(off + 6 + idx as usize * 2)); + } + } + } else { + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(count); + for i in 0..lim { + if reachable.contains(cov_gids[i]) { + targets.push(r.raw16(off + 6 + i * 2)); + } + } + } + } + } else if lookup_type == 2 { + // MultipleSubst: coverage gid → 多个 target + let cov_off = off + r.rd16(off + 2) as usize; + let seq_count = r.rd16(off + 4) as usize; + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(seq_count); + for i in 0..lim { + if !reachable.contains(cov_gids[i]) { + continue; + } + let seq_off = off + r.raw16(off + 6 + i * 2) as usize; + let glyph_count = r.raw16(seq_off) as usize; + for k in 0..glyph_count { + targets.push(r.raw16(seq_off + 2 + k * 2)); + } + } + } else if lookup_type == 3 { + // AlternateSubst: coverage gid → 多个候选 target(全部保留) + let cov_off = off + r.rd16(off + 2) as usize; + let alt_count = r.rd16(off + 4) as usize; + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(alt_count); + if cov_gids.len() > reachable.count() { + // 反转路径:遍历 reachable,对 covGids[0..lim] 二分 + for &g in &reachable.items { + let mut lo: usize = 0; + let mut hi: usize = lim; + while lo < hi { + let mid = (lo + hi) >> 1; + let mg = cov_gids[mid]; + if mg < g { + lo = mid + 1; + } else if mg > g { + hi = mid; + } else { + let alt_off = off + r.raw16(off + 6 + mid * 2) as usize; + let cnt = r.raw16(alt_off) as usize; + for k in 0..cnt { + targets.push(r.raw16(alt_off + 2 + k * 2)); + } + break; + } + } + } + } else { + for i in 0..lim { + if !reachable.contains(cov_gids[i]) { + continue; + } + let alt_off = off + r.raw16(off + 6 + i * 2) as usize; + let cnt = r.raw16(alt_off) as usize; + for k in 0..cnt { + targets.push(r.raw16(alt_off + 2 + k * 2)); + } + } + } + } else if lookup_type == 4 { + // LigatureSubst: 全部 component 在子集 → target gid + let cov_off = off + r.rd16(off + 2) as usize; + let set_count = r.rd16(off + 4) as usize; + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(set_count); + for i in 0..lim { + // 第一分量(coverage gid)不在子集时整条 ligature 不触发,跳过整个 LigatureSet + if !reachable.contains(cov_gids[i]) { + continue; + } + let set_off = off + r.raw16(off + 6 + i * 2) as usize; + let lig_count = r.raw16(set_off) as usize; + for j in 0..lig_count { + let lig_off = set_off + r.raw16(set_off + 2 + j * 2) as usize; + let comp_count = r.raw16(lig_off) as usize; + let target = r.raw16(lig_off + 2); + let mut all_in = true; + let mut k: usize = 0; + while k + 1 < comp_count { + if !reachable.contains(r.raw16(lig_off + 4 + k * 2)) { + all_in = false; + break; + } + k += 1; + } + if all_in { + targets.push(target); + } + } + } + } + // type5 ReverseChain / type6 ChainedContext 不直接产生 target + targets +} + +/// 收集 type6 ChainedContext subtable 中「可触发规则」引用的 lookup index 与所需 context gid +/// (对应 TS collectChainRefs;stable 返回值仅 TS 跨轮记忆用,此处省略) +fn collect_chain_refs( + r: &Reader, + off: usize, + refs: &mut OrderedGidSet, + context_gids: &mut OrderedGidSet, + reachable: &OrderedGidSet, +) { + let format = r.rd16(off); + if format == 1 { + // format1: coverage(gid) + SubRuleSet 数组,按 coverage gid 索引 + let cov_off = off + r.rd16(off + 2) as usize; + let cov_gids = read_coverage_gids(r, cov_off); + let set_count = r.rd16(off + 4) as usize; + let lim = cov_gids.len().min(set_count); + for i in 0..lim { + // 第一分量(coverage gid)须在子集,否则该 SubRuleSet 不触发 + if !reachable.contains(cov_gids[i]) { + continue; + } + context_gids.add(cov_gids[i]); + let set_off_rel = r.raw16(off + 6 + i * 2) as usize; + if set_off_rel == 0 { + continue; + } + let set_off = off + set_off_rel; + let rule_count = r.raw16(set_off) as usize; + for j in 0..rule_count { + let rule_off = set_off + r.raw16(set_off + 2 + j * 2) as usize; + collect_chain_rule_refs(r, rule_off, refs, context_gids, reachable, true); + } + } + } else if format == 2 { + // format2: 三个 ClassDef + 按 input 第一分量 class 索引的 SubClassSet。 + // class index 不是 gid,无法 inSubset 判断,保守收集全部被引用 lookup 与 ClassDef gid。 + let class_set_count = r.rd16(off + 10) as usize; + for i in 0..class_set_count { + let set_off_rel = r.raw16(off + 12 + i * 2) as usize; + if set_off_rel == 0 { + continue; + } + let set_off = off + set_off_rel; + let rule_count = r.raw16(set_off) as usize; + for j in 0..rule_count { + let rule_off = set_off + r.raw16(set_off + 2 + j * 2) as usize; + collect_chain_rule_refs(r, rule_off, refs, context_gids, reachable, false); + } + } + } else if format == 3 { + // format3: 显式 coverage 数组(backtrack/input/lookahead)+ SubstLookupRecords。 + // 第一遍:逐 coverage 找首个不在子集的 gid,全在子集才可触发。 + let mut p = off + 2; + let mut triggerable = true; + let mut seg: usize = 0; + while seg < 3 && triggerable { + let cnt = r.rd16(p) as usize; + p += 2; + for k in 0..cnt { + let cov_off = off + r.raw16(p + k * 2) as usize; + if coverage_first_excluded_gid(r, cov_off, reachable).is_some() { + triggerable = false; + break; + } + } + p += cnt * 2; + seg += 1; + } + if triggerable { + // 第二遍:三段 coverage 全部 gid 收进 contextGids + 收集 refs + let mut p2 = off + 2; + let mut seg2: usize = 0; + while seg2 < 3 { + let cnt = r.rd16(p2) as usize; + p2 += 2; + for k in 0..cnt { + let cov_gids = read_coverage_gids(r, off + r.raw16(p2 + k * 2) as usize); + for g in cov_gids { + context_gids.add(g); + } + } + p2 += cnt * 2; + seg2 += 1; + } + let subst_count = r.rd16(p2) as usize; + for k in 0..subst_count { + refs.add(r.raw16(p2 + 2 + k * 4 + 2)); + } + } + } +} + +/// 从一条 ChainSubstRule 收集引用的 lookup index 与 context gid。 +/// is_gid_format=true(format1):元素为 gid,全部在子集才收集(校验失败直接返回); +/// false(format2):元素为 class index,原样收集 refs(不判断 gid)。 +fn collect_chain_rule_refs( + r: &Reader, + rule_off: usize, + refs: &mut OrderedGidSet, + context_gids: &mut OrderedGidSet, + reachable: &OrderedGidSet, + is_gid_format: bool, +) { + // format1/2 rule: backtrackCount + backtrack[] + inputCount + input[] + lookaheadCount + lookahead[] + substCount + substRecords[] + let backtrack_count = r.rd16(rule_off) as usize; + let backtrack_end = rule_off + 2 + backtrack_count * 2; + let input_count = r.rd16(backtrack_end) as usize; + let input_len = if input_count > 0 { input_count - 1 } else { 0 }; + let input_end = backtrack_end + 2 + input_len * 2; + let lookahead_count = r.rd16(input_end) as usize; + let lookahead_end = input_end + 2 + lookahead_count * 2; + let subst_count = r.rd16(lookahead_end) as usize; + + if is_gid_format { + // 第一遍:校验 backtrack + input + lookahead 全部 gid 在子集(遇子集外即放弃规则) + let mut q = rule_off + 2; + for k in 0..backtrack_count { + if !reachable.contains(r.raw16(q + k * 2)) { + return; + } + } + q += backtrack_count * 2 + 2; + for k in 0..input_len { + if !reachable.contains(r.raw16(q + k * 2)) { + return; + } + } + q += input_len * 2 + 2; + for k in 0..lookahead_count { + if !reachable.contains(r.raw16(q + k * 2)) { + return; + } + } + // 第二遍:全部在子集,收集 context gid + q = rule_off + 2; + for k in 0..backtrack_count { + context_gids.add(r.raw16(q + k * 2)); + } + q += backtrack_count * 2 + 2; + for k in 0..input_len { + context_gids.add(r.raw16(q + k * 2)); + } + q += input_len * 2 + 2; + for k in 0..lookahead_count { + context_gids.add(r.raw16(q + k * 2)); + } + } + for k in 0..subst_count { + // SubstLookupRecord: sequenceIndex(2) + lookupListIndex(2) + refs.add(r.raw16(lookahead_end + 2 + k * 4 + 2)); + } +} + +// ===== GSUB 表子集化(gsub-subset.ts)===== + +/// 单条 ChainSubRule(重映射后) +struct ChainRule { + back: Vec, + input: Vec, + look: Vec, + records: Vec, +} + +/// SubstLookupRecord:sequenceIndex + lookupListIndex +#[derive(Clone, Copy)] +struct Rec { + seq: u16, + lookup_idx: u16, +} + +struct SingleEntry { + from: u16, + to: u16, +} + +struct SeqEntry { + from: u16, + seq: Vec, +} + +struct Lig { + comp: Vec, + lig: u16, +} + +struct LigEntry { + from: u16, + ligs: Vec, +} + +struct ChainEntry { + first_gid: u16, + rules: Vec, +} + +/// 从一组(子集内的)新 gid 序列写出 Coverage 表(假定升序无重复),返回起始偏移。 +/// format 判据与 TS 一致:rangeCount*6 < n*2 选 format2,否则 format1。 +fn emit_coverage(w: &mut Writer, new_gids: &[u16]) -> usize { + let off = w.len(); + let n = new_gids.len(); + let mut range_starts: Vec = Vec::new(); + let mut range_ends: Vec = Vec::new(); + let mut i: usize = 0; + while i < n { + let start = new_gids[i]; + let mut j = i; + while j + 1 < n && new_gids[j + 1] == new_gids[j].wrapping_add(1) { + j += 1; + } + range_starts.push(start); + range_ends.push(new_gids[j]); + i = j + 1; + } + let range_count = range_starts.len(); + if range_count > 0 && range_count * 6 < n * 2 { + w.w16(2); + w.w16(range_count as u16); + let mut cov_index: u16 = 0; + for (&rs, &re) in range_starts.iter().zip(range_ends.iter()) { + w.w16(rs); + w.w16(re); + w.w16(cov_index); + cov_index = cov_index.wrapping_add(re.wrapping_sub(rs).wrapping_add(1)); + } + } else { + w.w16(1); + w.w16(n as u16); + for &g in new_gids { + w.w16(g); + } + } + off +} + +/// 写出合法「空 subtable」用于降级(format:SingleSubst 用 2,其余用 1;coverageOffset 恒 6) +fn write_empty_subtable(w: &mut Writer, effective_type: i32) { + let format: u16 = if effective_type == 1 { 2 } else { 1 }; + w.w16(format); + w.w16(6); + w.w16(0); + w.w16(1); // 空 coverage:format1 + count0 + w.w16(0); +} + +/// 读取 ClassDef 表为 (新 gid → classIndex) map,class index 原样保留(对应 TS readClassDefMap) +fn read_class_def_map(ctx: &SubCtx, off: usize) -> HashMap { + let mut result: HashMap = HashMap::new(); + if off == 0 { + return result; + } + let r = ctx.r; + let format = r.rd16(off); + if format == 1 { + let start_gid = u32::from(r.rd16(off + 2)); + let count = r.rd16(off + 4) as usize; + for i in 0..count { + let orig_gid = start_gid + i as u32; + if let Some(new_gid) = ctx.remap(orig_gid) { + result.insert(new_gid, r.raw16(off + 6 + i * 2)); + } + } + } else if format == 2 { + let range_count = r.rd16(off + 2) as usize; + let sorted = &ctx.sorted_subset; + let sn = sorted.len(); + if sn == 0 { + return result; + } + let ranges_base = off + 4; + let min_subset = sorted[0]; + let max_subset = sorted[sn - 1]; + for i in 0..range_count { + let p = ranges_base + i * 6; + let start = r.raw16(p); + let end = r.raw16(p + 2); + if end < min_subset || start > max_subset { + continue; + } + let cls = r.raw16(p + 4); + // 二分定位第一个 >= start 的子集 gid,顺序遍历到 > end 为止 + let mut lo: usize = 0; + let mut hi: usize = sn; + while lo < hi { + let mid = (lo + hi) >> 1; + if sorted[mid] < start { + lo = mid + 1; + } else { + hi = mid; + } + } + let mut j = lo; + while j < sn { + let g = sorted[j]; + if g > end { + break; + } + // @intCast(i32→u16):sorted 中的 gid 必在子集内,映射值 ≥ 0 + result.insert(ctx.gid_lookup[g as usize] as u16, cls); + j += 1; + } + } + } + result +} + +/// 从 (新 gid → class) map 写出 ClassDef(format2 区间),返回起始偏移 +fn write_class_def_from_map(w: &mut Writer, map: &HashMap) -> usize { + let off = w.len(); + if map.is_empty() { + w.w16(2); + w.w16(0); + return off; + } + // map 迭代序不影响输出:entries 随后按 gid 升序排序(key 单射,排序全序确定) + let mut entries: Vec<(u16, u16)> = map.iter().map(|(&gid, &cls)| (gid, cls)).collect(); + entries.sort_unstable_by_key(|e| e.0); + // 连续同 class 折叠为 range + let mut ranges: Vec<(u16, u16, u16)> = Vec::new(); // (start, end, cls) + let mut i: usize = 0; + while i < entries.len() { + let cls = entries[i].1; + let mut j = i; + while j + 1 < entries.len() + && entries[j + 1].0 == entries[j].0.wrapping_add(1) + && entries[j + 1].1 == cls + { + j += 1; + } + ranges.push((entries[i].0, entries[j].0, cls)); + i = j + 1; + } + w.w16(2); + w.w16(ranges.len() as u16); + for rg in &ranges { + w.w16(rg.0); + w.w16(rg.1); + w.w16(rg.2); + } + off +} + +/// 廉价预检:subtable 是否可跳过深度序列化(输出空 subtable)。 +/// format2 class 驱动不预检(主 coverage 全空不代表无效)。 +fn is_subtable_skipable_by_coverage(ctx: &SubCtx, off: usize, lookup_type: i32) -> bool { + let r = ctx.r; + let data_len = r.data.len(); + if lookup_type == 6 { + if off + 2 > data_len { + return false; + } + let chain_fmt = r.raw16(off); + if chain_fmt == 2 { + return false; + } + if chain_fmt == 3 { + let mut p = off + 2; + for _grp in 0..3 { + if p + 2 > data_len { + return false; + } + let cnt = r.raw16(p) as usize; + p += 2; + for k in 0..cnt { + if p + 2 > data_len { + return false; + } + let cov_off = off + r.raw16(p + k * 2) as usize; + if coverage_all_out_of_subset(ctx, cov_off) { + return true; + } + } + p += cnt * 2; + } + return false; + } + } + if off + 4 > data_len { + return false; + } + let cov_off = off + r.raw16(off + 2) as usize; + coverage_all_out_of_subset(ctx, cov_off) +} + +/// 单个 subtable 序列化分发。返回 false 表示该 subtable 无法重映射(调用方降级空 subtable) +fn serialize_subtable(w: &mut Writer, ctx: &mut SubCtx, off: usize, lookup_type: i32, skipable: bool) -> bool { + let r = ctx.r; + if skipable { + return false; + } + r.clear_error(); + let ok: bool = match lookup_type { + 1 => serialize_single_subst(w, ctx, off), + 2 => serialize_multiple_subst(w, ctx, off), + 3 => serialize_alternate_subst(w, ctx, off), + 4 => serialize_ligature_subst(w, ctx, off), + 6 => serialize_chained_context_subst(w, ctx, off), + _ => false, + }; + if r.error_flag.get() { + return false; + } + ok +} + +/// SingleSubst(type1):format1 delta / format2 数组;统一 delta 时用 format1,否则 format2 +fn serialize_single_subst(w: &mut Writer, ctx: &mut SubCtx, off: usize) -> bool { + let r = ctx.r; + let format = r.rd16(off); + let cov_off = off + r.rd16(off + 2) as usize; + let mut entries: Vec = Vec::new(); + if format == 1 { + let delta = r.rd16s(off + 4); + let cov_gids = read_coverage_gids(r, cov_off); + for g in cov_gids { + let from_new = ctx.remap(u32::from(g)); + let to_new = ctx.remap(u32::from(g.wrapping_add(delta as u16))); + if let (Some(from), Some(to)) = (from_new, to_new) { + entries.push(SingleEntry { from, to }); + } + } + } else if format == 2 { + let count = r.rd16(off + 4) as usize; + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(count); + for i in 0..lim { + let from_new = ctx.remap(u32::from(cov_gids[i])); + let to_new = ctx.remap(u32::from(r.raw16(off + 6 + i * 2))); + if let (Some(from), Some(to)) = (from_new, to_new) { + entries.push(SingleEntry { from, to }); + } + } + } else { + return false; + } + if entries.is_empty() { + return false; + } + // 按 from 升序排序:coverage(emitCoverage 强制升序)与 target 数组按下标配对 + entries.sort_unstable_by_key(|e| e.from); + + let first_delta = entries[0].to.wrapping_sub(entries[0].from); + let uniform = entries.iter().all(|e| e.to.wrapping_sub(e.from) == first_delta); + + let sub_start = w.len(); + let cov_slot = sub_start + 2; + let froms: Vec = entries.iter().map(|e| e.from).collect(); + if uniform { + w.w16(1); + w.w16(0); // coverage 偏移槽占位 + w.w16(first_delta); + } else { + w.w16(2); + w.w16(0); + w.w16(entries.len() as u16); + for e in &entries { + w.w16(e.to); + } + } + let cov_pos = emit_coverage(w, &froms); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + true +} + +/// MultipleSubst(type2):coverage + sequence 数组(每项 = gid 数组) +fn serialize_multiple_subst(w: &mut Writer, ctx: &mut SubCtx, off: usize) -> bool { + let r = ctx.r; + let cov_off = off + r.rd16(off + 2) as usize; + let seq_count = r.rd16(off + 4) as usize; + let mut entries: Vec = Vec::new(); + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(seq_count); + for i in 0..lim { + let Some(from_new) = ctx.remap(u32::from(cov_gids[i])) else { + continue; + }; + let seq_off = off + r.raw16(off + 6 + i * 2) as usize; + let glyph_count = r.raw16(seq_off) as usize; + let mut new_seq: Vec = Vec::new(); + for k in 0..glyph_count { + if let Some(g) = ctx.remap(u32::from(r.raw16(seq_off + 2 + k * 2))) { + new_seq.push(g); + } + } + if !new_seq.is_empty() { + entries.push(SeqEntry { from: from_new, seq: new_seq }); + } + } + if entries.is_empty() { + return false; + } + entries.sort_unstable_by_key(|e| e.from); + + let sub_start = w.len(); + let cov_slot = sub_start + 2; + let seq_slots = sub_start + 6; + let froms: Vec = entries.iter().map(|e| e.from).collect(); + w.w16(1); + w.w16(0); // coverage 偏移槽 + w.w16(entries.len() as u16); + for _ in 0..entries.len() { + w.w16(0); // sequence 偏移槽 + } + let cov_pos = emit_coverage(w, &froms); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + for (ei, e) in entries.iter().enumerate() { + let seq_pos = w.len(); + w.w16at(seq_slots + ei * 2, (seq_pos - sub_start) as u16); + w.w16(e.seq.len() as u16); + for &g in &e.seq { + w.w16(g); + } + } + true +} + +/// AlternateSubst(type3):与 MultipleSubst 结构同形,仅语义不同 +fn serialize_alternate_subst(w: &mut Writer, ctx: &mut SubCtx, off: usize) -> bool { + let r = ctx.r; + let cov_off = off + r.rd16(off + 2) as usize; + let alt_count = r.rd16(off + 4) as usize; + let mut entries: Vec = Vec::new(); + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(alt_count); + for i in 0..lim { + let Some(from_new) = ctx.remap(u32::from(cov_gids[i])) else { + continue; + }; + let alt_off = off + r.raw16(off + 6 + i * 2) as usize; + let cnt = r.raw16(alt_off) as usize; + let mut new_alts: Vec = Vec::new(); + for k in 0..cnt { + if let Some(g) = ctx.remap(u32::from(r.raw16(alt_off + 2 + k * 2))) { + new_alts.push(g); + } + } + if !new_alts.is_empty() { + entries.push(SeqEntry { from: from_new, seq: new_alts }); + } + } + if entries.is_empty() { + return false; + } + entries.sort_unstable_by_key(|e| e.from); + + let sub_start = w.len(); + let cov_slot = sub_start + 2; + let alt_slots = sub_start + 6; + let froms: Vec = entries.iter().map(|e| e.from).collect(); + w.w16(1); + w.w16(0); + w.w16(entries.len() as u16); + for _ in 0..entries.len() { + w.w16(0); + } + let cov_pos = emit_coverage(w, &froms); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + for (ei, e) in entries.iter().enumerate() { + let alt_pos = w.len(); + w.w16at(alt_slots + ei * 2, (alt_pos - sub_start) as u16); + w.w16(e.seq.len() as u16); + for &g in &e.seq { + w.w16(g); + } + } + true +} + +/// LigatureSubst(type4):coverage + ligature set 数组 +fn serialize_ligature_subst(w: &mut Writer, ctx: &mut SubCtx, off: usize) -> bool { + let r = ctx.r; + let cov_off = off + r.rd16(off + 2) as usize; + let set_count = r.rd16(off + 4) as usize; + let mut entries: Vec = Vec::new(); + let cov_gids = read_coverage_gids(r, cov_off); + let lim = cov_gids.len().min(set_count); + for i in 0..lim { + let Some(from_new) = ctx.remap(u32::from(cov_gids[i])) else { + continue; + }; + let set_off = off + r.raw16(off + 6 + i * 2) as usize; + let lig_count = r.raw16(set_off) as usize; + let mut new_ligs: Vec = Vec::new(); + for j in 0..lig_count { + let lig_off = set_off + r.raw16(set_off + 2 + j * 2) as usize; + let comp_count = r.raw16(lig_off) as usize; + let Some(lig_new) = ctx.remap(u32::from(r.raw16(lig_off + 2))) else { + continue; + }; + // components 从第 2 字形开始(第 1 字形即 coverage 字形),compCount 含第 1 字形 + let mut comp_new: Vec = vec![from_new]; + let mut ok = true; + let mut k: usize = 0; + while k + 1 < comp_count { + match ctx.remap(u32::from(r.raw16(lig_off + 4 + k * 2))) { + Some(c) => comp_new.push(c), + None => { + ok = false; + break; + } + } + k += 1; + } + if ok { + new_ligs.push(Lig { comp: comp_new, lig: lig_new }); + } + } + if !new_ligs.is_empty() { + entries.push(LigEntry { from: from_new, ligs: new_ligs }); + } + } + if entries.is_empty() { + return false; + } + entries.sort_unstable_by_key(|e| e.from); + + let sub_start = w.len(); + let cov_slot = sub_start + 2; + let set_slots = sub_start + 6; + let froms: Vec = entries.iter().map(|e| e.from).collect(); + w.w16(1); + w.w16(0); + w.w16(entries.len() as u16); + for _ in 0..entries.len() { + w.w16(0); + } + let cov_pos = emit_coverage(w, &froms); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + for (ei, e) in entries.iter().enumerate() { + let set_pos = w.len(); + w.w16at(set_slots + ei * 2, (set_pos - sub_start) as u16); + w.w16(e.ligs.len() as u16); + let lig_slots = w.len(); + for _ in 0..e.ligs.len() { + w.w16(0); + } + for (lj2, lig) in e.ligs.iter().enumerate() { + let lig_pos = w.len(); + w.w16at(lig_slots + lj2 * 2, (lig_pos - set_pos) as u16); + w.w16(lig.comp.len() as u16); + w.w16(lig.lig); + // 第 2 个分量起 + for &g in &lig.comp[1..] { + w.w16(g); + } + } + } + true +} + +/// 解析 format1/format2 的单条 ChainSubRule,返回重映射后的规则或 None(含子集外 gid) +fn parse_chain_rule_format1or2(ctx: &SubCtx, rule_off: usize, is_gid_format: bool) -> Option { + let r = ctx.r; + let back_count = r.rd16(rule_off) as usize; + if back_count > 255 { + return None; + } + let mut p = rule_off + 2; + let back = read_chain_seq(ctx, p, back_count, is_gid_format)?; + p += back_count * 2; + let input_count = r.rd16(p) as usize; + // inputCount 为 0 异常(ChainSubRule 至少含第一分量),返回 None + if input_count == 0 || input_count > 255 { + return None; + } + p += 2; + // input 序列不含第一分量(第一分量由 coverage/class 决定) + let input = read_chain_seq(ctx, p, input_count - 1, is_gid_format)?; + p += (input_count - 1) * 2; + let look_count = r.rd16(p) as usize; + if look_count > 255 { + return None; + } + p += 2; + let look = read_chain_seq(ctx, p, look_count, is_gid_format)?; + p += look_count * 2; + let seq_count = r.rd16(p) as usize; + if seq_count > 255 { + return None; + } + p += 2; + let mut records: Vec = Vec::new(); + for k in 0..seq_count { + records.push(Rec { seq: r.raw16(p + k * 4), lookup_idx: r.raw16(p + k * 4 + 2) }); + } + Some(ChainRule { back, input, look, records }) +} + +/// 读 ChainSubRule 的一个 gid/class 序列;format1 遇子集外 gid 返回 None +fn read_chain_seq(ctx: &SubCtx, p: usize, count: usize, is_gid_format: bool) -> Option> { + let r = ctx.r; + let mut out: Vec = Vec::new(); + for k in 0..count { + let raw = r.raw16(p + k * 2); + if is_gid_format { + let m = ctx.remap(u32::from(raw))?; + out.push(m); + } else { + out.push(raw); + } + } + Some(out) +} + +/// 写出单条 ChainSubRule 主体(不含偏移量槽) +fn write_chain_rule_body(w: &mut Writer, rule: &ChainRule) { + w.w16(rule.back.len() as u16); + for &g in &rule.back { + w.w16(g); + } + // inputCount 含第一分量 + w.w16((rule.input.len() + 1) as u16); + for &g in &rule.input { + w.w16(g); + } + w.w16(rule.look.len() as u16); + for &g in &rule.look { + w.w16(g); + } + w.w16(rule.records.len() as u16); + for rc in &rule.records { + w.w16(rc.seq); + w.w16(rc.lookup_idx); + } +} + +/// ChainedContextSubst(type6)subtable 序列化,format1/2/3 均支持 +fn serialize_chained_context_subst(w: &mut Writer, ctx: &mut SubCtx, off: usize) -> bool { + let r = ctx.r; + let format = r.rd16(off); + if format == 1 { + let cov_off = off + r.rd16(off + 2) as usize; + // 唯一带缓存的 readCoverageGids 调用方(TS 936 行):填充 covCache 的 gids 侧, + // 供同 off 的 fmt3/writeChainFormat2 命中「原序重映射」分支 + let cov_gids = cov_gids_cached(ctx, cov_off); + let rule_set_count = r.rd16(off + 4) as usize; + if rule_set_count > 0x7fff { + return false; + } + let mut entries: Vec = Vec::new(); + let lim = cov_gids.len().min(rule_set_count); + for i in 0..lim { + let Some(first_new) = ctx.remap(u32::from(cov_gids[i])) else { + continue; + }; + let set_off = off + r.raw16(off + 6 + i * 2) as usize; + let rule_count = r.raw16(set_off) as usize; + if rule_count > 0x7fff { + return false; + } + let mut valid_rules: Vec = Vec::new(); + for j in 0..rule_count { + let rule_off = set_off + r.raw16(set_off + 2 + j * 2) as usize; + if let Some(parsed) = parse_chain_rule_format1or2(ctx, rule_off, true) { + valid_rules.push(parsed); + } + } + if !valid_rules.is_empty() { + entries.push(ChainEntry { first_gid: first_new, rules: valid_rules }); + } + } + if entries.is_empty() { + return false; + } + entries.sort_unstable_by_key(|e| e.first_gid); + write_chain_format1(w, &entries); + return true; + } + + if format == 2 { + // format2(ClassDef 匹配):Coverage + 三个 ClassDef + 按 input 第一分量 class 索引的 rule sets。 + // class index 不重编号(保留 class 0 的「未分类」语义),仅重映射 ClassDef 内的 gid。 + let coverage_off = off + r.rd16(off + 2) as usize; + let backtrack_cd_off = off + r.rd16(off + 4) as usize; + let input_cd_off = off + r.rd16(off + 6) as usize; + let lookahead_cd_off = off + r.rd16(off + 8) as usize; + let class_set_count = r.rd16(off + 10) as usize; + // classSetCount 异常大(>256)意味着扩展 padding / 异常结构,严格解析读到重叠垃圾数据,降级 + if class_set_count > 256 { + return false; + } + + let mut class_sets: Vec>> = + (0..class_set_count).map(|_| None).collect(); + let mut any = false; + for i in 0..class_set_count { + let set_off_rel = r.raw16(off + 12 + i * 2) as usize; + if set_off_rel == 0 { + continue; + } + let set_off = off + set_off_rel; + let rule_count = r.raw16(set_off) as usize; + if rule_count > 0x7fff { + return false; + } + for j in 0..rule_count { + let rule_off = set_off + r.raw16(set_off + 2 + j * 2) as usize; + // format2 元素是 class index(非 gid),规则恒保留 + let Some(parsed) = parse_chain_rule_format1or2(ctx, rule_off, false) else { + continue; + }; + class_sets[i].get_or_insert_with(Vec::new).push(parsed); + any = true; + } + } + if !any { + return false; + } + write_chain_format2(w, ctx, coverage_off, backtrack_cd_off, input_cd_off, lookahead_cd_off, &class_sets); + return true; + } + + if format == 3 { + let Some(parsed) = parse_chain_format3(ctx, off) else { + return false; + }; + write_chain_format3(w, parsed); + return true; + } + + false +} + +/// 写出 ChainedContext format1(coverage + rule sets) +fn write_chain_format1(w: &mut Writer, entries: &[ChainEntry]) { + let sub_start = w.len(); + let cov_slot = sub_start + 2; + let set_slots = sub_start + 6; + let firsts: Vec = entries.iter().map(|e| e.first_gid).collect(); + w.w16(1); + w.w16(0); // coverage 偏移槽 + w.w16(entries.len() as u16); + for _ in 0..entries.len() { + w.w16(0); // SubRuleSet 偏移槽 + } + let cov_pos = emit_coverage(w, &firsts); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + for (ei, e) in entries.iter().enumerate() { + let set_pos = w.len(); + w.w16at(set_slots + ei * 2, (set_pos - sub_start) as u16); + w.w16(e.rules.len() as u16); + let rule_slots = w.len(); + for _ in 0..e.rules.len() { + w.w16(0); + } + for (rj2, rule) in e.rules.iter().enumerate() { + let rule_pos = w.len(); + w.w16at(rule_slots + rj2 * 2, (rule_pos - set_pos) as u16); + write_chain_rule_body(w, rule); + } + } +} + +/// 写出 ChainedContext format2(三个 ClassDef + 按 class 的 rule sets) +#[allow(clippy::too_many_arguments)] +fn write_chain_format2( + w: &mut Writer, + ctx: &mut SubCtx, + coverage_off: usize, + backtrack_cd_off: usize, + input_cd_off: usize, + lookahead_cd_off: usize, + class_sets: &[Option>], +) { + let sub_start = w.len(); + let cov_slot = sub_start + 2; + let back_slot = sub_start + 4; + let input_slot = sub_start + 6; + let look_slot = sub_start + 8; + w.w16(2); + w.w16(0); + w.w16(0); + w.w16(0); + w.w16(0); + + // classSetCount = 最大非空 class index + 1(保持原始 class index) + let mut max_class: i64 = -1; + for (i, cs) in class_sets.iter().enumerate() { + if cs.is_some() && i as i64 > max_class { + max_class = i as i64; + } + } + let class_set_count: usize = if max_class < 0 { 0 } else { (max_class + 1) as usize }; + w.w16(class_set_count as u16); + let set_slots = w.len(); + for i in 0..class_set_count { + // 0xAA 只为占位区分,实际值由 w16at 回填覆盖(对译 Zig 的占位写法,输出一致) + w.w16(if i < class_sets.len() && class_sets[i].is_some() { 0xAA } else { 0 }); + } + // 占位统一为 0:先全部写 0,稍后有规则的回填 + for i in 0..class_set_count { + w.w16at(set_slots + i * 2, 0); + } + + // Coverage 重映射:仅保留子集内 gid(readCoverageRemapped None → 写空 coverage) + let new_cov_gids: Vec = read_coverage_remapped(ctx, coverage_off).unwrap_or_default(); + let cov_pos = emit_coverage(w, &new_cov_gids); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + + // 重映射三个 ClassDef 的 gid(class index 不变) + let back_map = read_class_def_map(ctx, backtrack_cd_off); + let input_map = read_class_def_map(ctx, input_cd_off); + let look_map = read_class_def_map(ctx, lookahead_cd_off); + let back_pos = write_class_def_from_map(w, &back_map); + let input_pos = write_class_def_from_map(w, &input_map); + let look_pos = write_class_def_from_map(w, &look_map); + w.w16at(back_slot, (back_pos - sub_start) as u16); + w.w16at(input_slot, (input_pos - sub_start) as u16); + w.w16at(look_slot, (look_pos - sub_start) as u16); + + for i in 0..class_set_count { + let Some(rules) = &class_sets[i] else { continue }; + let set_pos = w.len(); + w.w16at(set_slots + i * 2, (set_pos - sub_start) as u16); + w.w16(rules.len() as u16); + let rule_slots = w.len(); + for _ in 0..rules.len() { + w.w16(0); + } + for (rj2, rule) in rules.iter().enumerate() { + let rule_pos = w.len(); + w.w16at(rule_slots + rj2 * 2, (rule_pos - set_pos) as u16); + write_chain_rule_body(w, rule); + } + } +} + +/// 解析 format3:显式 coverage 数组 + records;任一 coverage 全子集外(原非空)→ None +struct ChainFormat3 { + back_covs: Vec>, + input_covs: Vec>, + look_covs: Vec>, + records: Vec, +} + +fn parse_chain_format3(ctx: &mut SubCtx, off: usize) -> Option { + let mut p = off + 2; + // 对译 Zig inline for 的三段 coverage 组(backtrack/input/lookahead) + let mut cov_groups: Vec>> = Vec::with_capacity(3); + for _ in 0..3 { + let count = ctx.r.rd16(p) as usize; + p += 2; + let mut arr: Vec> = Vec::new(); + for k in 0..count { + let cov_off = off + ctx.r.raw16(p + k * 2) as usize; + let new_gids = read_coverage_remapped(ctx, cov_off)?; + arr.push(new_gids); + } + p += count * 2; + cov_groups.push(arr); + } + let seq_count = ctx.r.rd16(p) as usize; + p += 2; + let mut records: Vec = Vec::new(); + for k in 0..seq_count { + records.push(Rec { seq: ctx.r.raw16(p + k * 4), lookup_idx: ctx.r.raw16(p + k * 4 + 2) }); + } + let mut cov_groups = cov_groups; + let look_covs = cov_groups.pop().expect("3 groups"); + let input_covs = cov_groups.pop().expect("3 groups"); + let back_covs = cov_groups.pop().expect("3 groups"); + Some(ChainFormat3 { back_covs, input_covs, look_covs, records }) +} + +/// 写出 format3:重映射后的 coverage 数组 + records +fn write_chain_format3(w: &mut Writer, parsed: ChainFormat3) { + let sub_start = w.len(); + let mut cov_slot_positions: Vec = Vec::new(); + w.w16(3); + w.w16(parsed.back_covs.len() as u16); + for _ in 0..parsed.back_covs.len() { + cov_slot_positions.push(w.len()); + w.w16(0); + } + w.w16(parsed.input_covs.len() as u16); + for _ in 0..parsed.input_covs.len() { + cov_slot_positions.push(w.len()); + w.w16(0); + } + w.w16(parsed.look_covs.len() as u16); + for _ in 0..parsed.look_covs.len() { + cov_slot_positions.push(w.len()); + w.w16(0); + } + w.w16(parsed.records.len() as u16); + for rc in &parsed.records { + w.w16(rc.seq); + w.w16(rc.lookup_idx); + } + + // 写出各组 coverage 并回填偏移槽(相对 subStart) + let mut pos_idx: usize = 0; + for cov in parsed.back_covs.iter().chain(&parsed.input_covs).chain(&parsed.look_covs) { + let pos = emit_coverage(w, cov); + w.w16at(cov_slot_positions[pos_idx], (pos - sub_start) as u16); + pos_idx += 1; + } +} + +/// ScriptList 连续字节跨度(ot-bytes.ts scriptListSpan);解析异常返回 -1 +fn script_list_span(r: &Reader, list_abs: usize) -> i64 { + r.clear_error(); + let script_count = r.rd16(list_abs) as usize; + let mut span: usize = 2 + script_count * 6; + for i in 0..script_count { + let script_rel = r.rd16(list_abs + 2 + i * 6 + 4) as usize; + let script_abs = list_abs + script_rel; + let default_lang_sys_off = r.rd16(script_abs) as usize; + let lang_sys_count = r.rd16(script_abs + 2) as usize; + span = span.max(script_rel + 4 + lang_sys_count * 6); + if default_lang_sys_off != 0 { + let dl_rel = script_rel + default_lang_sys_off; + let fic = r.rd16(script_abs + default_lang_sys_off + 4) as usize; + span = span.max(dl_rel + 6 + fic * 2); + } + for li in 0..lang_sys_count { + let ls_rel = r.rd16(script_abs + 4 + li * 6 + 4) as usize; + let fic = r.rd16(script_abs + ls_rel + 4) as usize; + span = span.max(script_rel + ls_rel + 6 + fic * 2); + } + } + if r.error_flag.get() { + -1 + } else { + span as i64 + } +} + +/// FeatureList 连续字节跨度(ot-bytes.ts featureListSpan);解析异常返回 -1 +fn feature_list_span(r: &Reader, list_abs: usize) -> i64 { + r.clear_error(); + let feature_count = r.rd16(list_abs) as usize; + let mut span: usize = 2 + feature_count * 6; + for i in 0..feature_count { + let ft_rel = r.rd16(list_abs + 2 + i * 6 + 4) as usize; + let ft_abs = list_abs + ft_rel; + let lookup_index_count = r.rd16(ft_abs + 2) as usize; + span = span.max(ft_rel + 4 + lookup_index_count * 2); + } + if r.error_flag.get() { + -1 + } else { + span as i64 + } +} + +/// 拷贝一个 LangSys 表(lookupOrder 恒写 0) +fn copy_lang_sys(w: &mut Writer, r: &Reader, abs_off: usize) { + w.w16(0); + w.w16(r.rd16(abs_off + 2)); + let fic = r.rd16(abs_off + 4) as usize; + w.w16(fic as u16); + for fi in 0..fic { + w.w16(r.rd16(abs_off + 6 + fi * 2)); + } +} + +/// 重新序列化 ScriptList(GPOS/GSUB 通用);解析异常返回 None +fn serialize_script_list(r: &Reader, list_abs: usize) -> Option> { + r.clear_error(); + let mut w = Writer::new(); + let script_count = r.rd16(list_abs) as usize; + w.w16(script_count as u16); + let script_slots = w.len(); + for i in 0..script_count { + let s = list_abs + 2 + i * 6; + w.wbytes(&r.data[s..s + 4]); // tag 4 字节原样拷贝 + w.w16(0); // 偏移槽 + } + for i in 0..script_count { + let script_new_off = w.len(); + w.w16at(script_slots + i * 2, script_new_off as u16); // ScriptRecord 偏移相对 ScriptList 起始(writer 0) + let script_old_off = list_abs + r.rd16(list_abs + 2 + i * 6 + 4) as usize; + let default_lang_sys_off = r.rd16(script_old_off) as usize; + let lang_sys_count = r.rd16(script_old_off + 2) as usize; + let st_start = w.len(); + let default_slot = w.len(); + w.w16(0); // defaultLangSysOffset 槽(相对 ScriptTable 起始) + w.w16(lang_sys_count as u16); + let ls_slots = w.len(); + for li in 0..lang_sys_count { + let s = script_old_off + 4 + li * 6; + w.wbytes(&r.data[s..s + 4]); // LangSysRecord tag + w.w16(0); // 偏移槽 + } + if default_lang_sys_off != 0 { + let dl_pos = w.len(); + w.w16at(default_slot, (dl_pos - st_start) as u16); + copy_lang_sys(&mut w, r, script_old_off + default_lang_sys_off); + } + for li in 0..lang_sys_count { + let ls_old_off = script_old_off + r.rd16(script_old_off + 4 + li * 6 + 4) as usize; + let ls_pos = w.len(); + w.w16at(ls_slots + li * 2, (ls_pos - st_start) as u16); + copy_lang_sys(&mut w, r, ls_old_off); + } + } + if r.error_flag.get() { + return None; + } + Some(w.list) +} + +/// 重新序列化 FeatureList;解析异常返回 None +fn serialize_feature_list(r: &Reader, list_abs: usize) -> Option> { + r.clear_error(); + let mut w = Writer::new(); + let feature_count = r.rd16(list_abs) as usize; + w.w16(feature_count as u16); + let feature_slots = w.len(); + for i in 0..feature_count { + let s = list_abs + 2 + i * 6; + w.wbytes(&r.data[s..s + 4]); // tag 4 字节原样拷贝 + w.w16(0); // 偏移槽 + } + for i in 0..feature_count { + let ft_new_off = w.len(); + w.w16at(feature_slots + i * 2, ft_new_off as u16); + let ft_old_off = list_abs + r.rd16(list_abs + 2 + i * 6 + 4) as usize; + let feature_params_off = r.rd16(ft_old_off); + let lookup_index_count = r.rd16(ft_old_off + 2) as usize; + // featureParamsOffset 原样保留(非 0 时相对 FeatureTable,其内容不含 gid) + w.w16(feature_params_off); + w.w16(lookup_index_count as u16); + for li in 0..lookup_index_count { + w.w16(r.rd16(ft_old_off + 4 + li * 2)); + } + } + if r.error_flag.get() { + return None; + } + Some(w.list) +} + +/// GSUB 子集化入口(对应 TS subsetGSUB)。 +/// keep:子集保留的原始 gid 序列(新 gid = 下标;与 TS subsetGids 顺序语义一致)。 +/// 版本不支持时返回原始字节拷贝(TS 语义:原样返回)。 +pub fn subset_gsub(gsub_bytes: &[u8], keep: &[u16]) -> Result, GsubError> { + let r = Reader::new(gsub_bytes); + + // 原 gid→新 gid 查找表(下标=原 gid,值=新 gid,-1=不在子集) + let mut max_orig_gid: usize = 0; + for &g in keep { + if g as usize > max_orig_gid { + max_orig_gid = g as usize; + } + } + let mut gid_lookup = vec![-1i32; max_orig_gid + 1]; + for (new_gid, &g) in keep.iter().enumerate() { + gid_lookup[g as usize] = new_gid as i32; + } + let mut sorted_subset = keep.to_vec(); + sorted_subset.sort_unstable(); + + let mut ctx = SubCtx { r: &r, gid_lookup, sorted_subset, cov_cache: HashMap::new() }; + + // ---- GSUB Header ---- + let major = r.raw16(0); + let minor = r.raw16(2); + if major != 1 || minor > 1 { + return Ok(gsub_bytes.to_vec()); + } + let script_list_off = r.raw16(4) as usize; + let feature_list_off = r.raw16(6) as usize; + let lookup_list_off = r.raw16(8) as usize; + let lookups = parse_lookups(&r, lookup_list_off); + + // 第一遍:supported 判定 + 每子表 skipable 预扫描 + lookup 级 allEmpty + let mut supported = vec![false; lookups.len()]; + let mut all_empty = vec![false; lookups.len()]; + let mut skipable: Vec> = Vec::with_capacity(lookups.len()); + for (i, lk) in lookups.iter().enumerate() { + let et = lk.effective_type; + supported[i] = matches!(et, 1 | 2 | 3 | 4 | 6); + let subs = &lk.sub_offs; + let mut all = !subs.is_empty(); + let sk: Vec = subs + .iter() + .map(|&so| { + let s = is_subtable_skipable_by_coverage(&ctx, so, et); + if !s { + all = false; + } + s + }) + .collect(); + skipable.push(sk); + all_empty[i] = all; + } + + // ---- ScriptList / FeatureList ---- + let sl_span = script_list_span(&r, script_list_off); + let sl_contiguous = sl_span >= 0 && script_list_off + sl_span as usize <= feature_list_off; + let script_list_bytes: Option> = if sl_contiguous { + Some(gsub_bytes[script_list_off..script_list_off + sl_span as usize].to_vec()) + } else { + serialize_script_list(&r, script_list_off) + }; + let fl_span = feature_list_span(&r, feature_list_off); + let fl_contiguous = fl_span >= 0 && feature_list_off + fl_span as usize <= lookup_list_off; + let feature_list_bytes: Option> = if fl_contiguous { + Some(gsub_bytes[feature_list_off..feature_list_off + fl_span as usize].to_vec()) + } else { + serialize_feature_list(&r, feature_list_off) + }; + r.clear_error(); + // ScriptList/FeatureList 解析失败则整体保留原始 GSUB 字节(安全降级) + let (script_list_bytes, feature_list_bytes) = match (script_list_bytes, feature_list_bytes) { + (Some(sl), Some(fl)) => (sl, fl), + _ => return Ok(gsub_bytes.to_vec()), + }; + + // ---- 主 Writer(输出恒小于原表,按原表长度预分配)---- + let mut w = Writer::with_capacity(gsub_bytes.len()); + + // Header + w.w16(1); + w.w16(minor); + let sl_slot = w.len(); + w.w16(0); + let fl_slot = w.len(); + w.w16(0); + let ll_slot = w.len(); + w.w16(0); + + // ScriptList + let sl_abs = w.len(); + w.wbytes(&script_list_bytes); + // FeatureList + let fl_abs = w.len(); + w.wbytes(&feature_list_bytes); + + // LookupList + let ll_abs = w.len(); + w.w16(lookups.len() as u16); + let lookup_slots = w.len(); + for _ in 0..lookups.len() { + w.w16(0); + } + + for (i, lk) in lookups.iter().enumerate() { + let lookup_abs = w.len(); + let et = lk.effective_type; + if supported[i] { + let lookup_flag = r.rd16(lk.orig_off + 2); + let use_mark_filtering_set = (lookup_flag & 0x0010) != 0; + // 输出用 effectiveType(extension 解包后内嵌,不再用 extension 包裹) + w.w16(et as u16); + w.w16(lookup_flag); + if all_empty[i] { + // 全空 lookup 折叠 subCount=1 的单个空 subtable(feature 按 index 引用不受影响) + w.w16(1); + let lookup_start = w.len() - 6; + let subtable_slot = w.len(); + w.w16(0); + if use_mark_filtering_set { + w.w16(r.rd16(lk.orig_off + 6 + lk.sub_offs.len() * 2)); + } + let subtable_pos = w.len(); + write_empty_subtable(&mut w, et); + w.w16at(subtable_slot, (subtable_pos - lookup_start) as u16); + } else { + // 跳过 coverage gid 全不在子集的 subtable(渲染等价:必空 subtable 查不到字形) + let mut kept: Vec = Vec::new(); + for (j, &sk) in skipable[i].iter().enumerate() { + if !sk { + kept.push(j); + } + } + let kept_count = kept.len(); + w.w16(kept_count as u16); + let lookup_start = w.len() - 6; + let subtable_slots = w.len(); + for _ in 0..kept_count { + w.w16(0); + } + if use_mark_filtering_set { + w.w16(r.rd16(lk.orig_off + 6 + lk.sub_offs.len() * 2)); + } + for (j, &orig_idx) in kept.iter().enumerate() { + let before = w.len(); + let ok = serialize_subtable(&mut w, &mut ctx, lk.sub_offs[orig_idx], et, skipable[i][orig_idx]); + if !ok { + w.rollback(before); + write_empty_subtable(&mut w, et); + } + w.w16at(subtable_slots + j * 2, (before - lookup_start) as u16); + } + } + } else { + // 不支持的 lookup(type5 等):类型/flag 保留原值,单空 subtable 降级 + let lookup_flag = r.rd16(lk.orig_off + 2); + let use_mark_filtering_set = (lookup_flag & 0x0010) != 0; + w.w16(r.rd16(lk.orig_off)); + w.w16(lookup_flag); + w.w16(1); + let lookup_start = w.len() - 6; + let subtable_slot = w.len(); + w.w16(0); + if use_mark_filtering_set { + w.w16(r.rd16(lk.orig_off + 6 + lk.sub_offs.len() * 2)); + } + let subtable_pos = w.len(); + write_empty_subtable(&mut w, et); + w.w16at(subtable_slot, (subtable_pos - lookup_start) as u16); + } + // 回填 lookup 偏移槽(相对 LookupList 起始) + w.w16at(lookup_slots + i * 2, (lookup_abs - ll_abs) as u16); + } + + // Header 偏移回填 + w.w16at(sl_slot, sl_abs as u16); + w.w16at(fl_slot, fl_abs as u16); + w.w16at(ll_slot, ll_abs as u16); + + Ok(w.list) +} + +// ===== GPOS 子集化(对应 gpos-subset.ts:LookupType 1 SinglePos / 2 PairPos, +// Mark*(4/5/6)等 unsupported 降级空 subtable,版本不支持整体降级返回 None)===== + +/// ValueFormat 位:Device/VariationIndex 四位(含任一则整体降级) +const VF_DEVICE_MASK: u16 = 0x00F0; + +/// 一个 ValueRecord 占用的 uint16 数量(valueFormat 低 8 位的 set bit 数) +fn value_record_size(value_format: u16) -> usize { + let mut n: usize = 0; + let mut bits = value_format & 0xff; + while bits != 0 { + n += (bits & 1) as usize; + bits >>= 1; + } + n +} + +/// 写空 coverage 表(format1 + count0) +fn write_empty_coverage(w: &mut Writer) { + w.w16(1); + w.w16(0); +} + +/// 写合法的空 Position subtable(浏览器查不到字形跳过;unsupported lookup 保守降级用) +fn write_empty_pos_subtable(w: &mut Writer, effective_type: i32) { + w.w16(1); + if effective_type == 4 || effective_type == 5 || effective_type == 6 { + // MarkBase/MarkLig/MarkMark format1:12 字节头 + 空 markCoverage/baseCoverage/markArray/baseArray + w.w16(12); // markCoverageOff + w.w16(16); // baseCoverageOff + w.w16(0); // markClassCount = 0 + w.w16(20); // markArrayOff + w.w16(22); // baseArrayOff + write_empty_coverage(w); // @12 + write_empty_coverage(w); // @16 + w.w16(0); // markArray: markCount = 0 @20 + w.w16(0); // baseArray: baseCount = 0 @22 + return; + } + // coverageOff 相对 subtable 的常量:SinglePos/Cursive 等头 6 字节、PairPos 头 10 字节 + let coverage_off_const: u16 = if effective_type == 2 { 10 } else { 6 }; + w.w16(coverage_off_const); + if effective_type == 1 { + w.w16(0); // valueFormat = 0 + } else if effective_type == 2 { + w.w16(0); // valueFormat1 + w.w16(0); // valueFormat2 + w.w16(0); // pairSetCount + } else { + w.w16(0); // Cursive: entryExitCount=0;Context/ChainContext: ruleSetCount=0;-1: 同形 + } + write_empty_coverage(w); +} + +/// SinglePos/PairPos 的 coverage 是否含任意子集字形(提前退出;对应 TS subtableCoverageHits) +fn pos_subtable_coverage_hits(ctx: &SubCtx, sub_abs: usize) -> bool { + let r = ctx.r; + if sub_abs + 4 > r.data.len() { + return false; + } + let cov_abs = sub_abs + r.raw16(sub_abs + 2) as usize; + if cov_abs + 4 > r.data.len() { + return false; + } + let fmt = r.raw16(cov_abs); + if fmt == 1 { + let count = r.raw16(cov_abs + 2) as usize; + let base = cov_abs + 4; + if base + count * 2 > r.data.len() { + return false; + } + for i in 0..count { + if ctx.remap(u32::from(r.raw16(base + i * 2))).is_some() { + return true; + } + } + return false; + } + if fmt == 2 { + let range_count = r.raw16(cov_abs + 2) as usize; + let mut p = cov_abs + 4; + for _ in 0..range_count { + if p + 6 > r.data.len() { + break; + } + let start = r.raw16(p); + let end = r.raw16(p + 2); + // u32 循环避免 end=0xFFFF 时 u16 环绕 + let mut g: u32 = u32::from(start); + while g <= u32::from(end) { + if ctx.remap(g).is_some() { + return true; + } + g += 1; + } + p += 6; + } + return false; + } + true // 未知 format 保守视为命中(避免错误折叠) +} + +/// 写 ValueRecord(按 valueFormat 顺序 xPla/yPla/xAdv/yAdv;含 Device 位返回 false 整体降级) +fn write_value_record(w: &mut Writer, r: &Reader, abs_off: usize, value_format: u16) -> bool { + if value_format & VF_DEVICE_MASK != 0 { + return false; + } + let mut off = abs_off; + for bit in [0x0001u16, 0x0002, 0x0004, 0x0008] { + if value_format & bit != 0 { + // @bitCast(i16→u16):`as` 同为位模式重解释 + w.w16(r.rd16s(off) as u16); + off += 2; + } + } + true +} + +/// GPOS 版 ClassDef 输出(选更紧凑 format;fmt1 用 startGlyph/glyphCount 展开含 class0 段; +/// 与 gsub 版(恒 format2)不同,对应 TS gpos-subset emitClassDefFromClassMap) +fn emit_class_def_from_class_map(w: &mut Writer, class_map: &HashMap) -> usize { + let off = w.len(); + if class_map.is_empty() { + w.w16(1); + w.w16(0); + w.w16(0); + return off; + } + // map 迭代序不影响输出:entries 随后按 gid 升序排序(key 单射,排序全序确定) + let mut entries: Vec<(u16, u16)> = class_map.iter().map(|(&gid, &cls)| (gid, cls)).collect(); + entries.sort_unstable_by_key(|e| e.0); + // 连续同 class 折叠为 range + let mut ranges: Vec<(u16, u16, u16)> = Vec::new(); // (start, end, cls) + let mut i: usize = 0; + while i < entries.len() { + let cls = entries[i].1; + let mut j = i; + while j + 1 < entries.len() + && entries[j + 1].0 == entries[j].0.wrapping_add(1) + && entries[j + 1].1 == cls + { + j += 1; + } + ranges.push((entries[i].0, entries[j].0, cls)); + i = j + 1; + } + let list_start = entries[0].0; + let list_count: usize = entries[entries.len() - 1].0 as usize - list_start as usize + 1; + let list_cost: usize = 6 + list_count * 2; + let range_cost: usize = 4 + ranges.len() * 6; + if range_cost < list_cost { + w.w16(2); + w.w16(ranges.len() as u16); + for rg in &ranges { + w.w16(rg.0); + w.w16(rg.1); + w.w16(rg.2); + } + } else { + w.w16(1); + w.w16(list_start); + w.w16(list_count as u16); + for gid in list_start as usize..list_start as usize + list_count { + let cls = class_map.get(&(gid as u16)).copied().unwrap_or(0); + w.w16(cls); + } + } + off +} + +/// SinglePos 子表序列化(fmt1 共用 ValueRecord;fmt2 按 coverage index 对齐)。 +/// 失败(含 Device 位 / 未知 format)返回 false → 整体降级。 +fn serialize_single_pos(w: &mut Writer, ctx: &mut SubCtx, sub_abs: usize) -> bool { + let r = ctx.r; + let fmt = r.raw16(sub_abs); + let coverage_off = r.raw16(sub_abs + 2) as usize; + let value_format = r.raw16(sub_abs + 4); + let orig_gids = read_coverage_gids(r, sub_abs + coverage_off); + let sz = value_record_size(value_format); + + struct Kept { + new_gid: u16, + value_abs: usize, + } + let mut kept: Vec = Vec::new(); + for (idx, &g) in orig_gids.iter().enumerate() { + let Some(new_gid) = ctx.remap(u32::from(g)) else { + continue; + }; + if fmt == 1 { + kept.push(Kept { new_gid, value_abs: sub_abs + 6 }); + } else if fmt == 2 { + kept.push(Kept { new_gid, value_abs: sub_abs + 8 + idx * sz * 2 }); + } else { + return false; + } + } + kept.sort_unstable_by_key(|k| k.new_gid); + + let sub_start = w.len(); + w.w16(fmt); // 1 或 2 原样保留(无降级折叠) + let cov_slot = w.len(); + w.w16(0); + w.w16(value_format); + if fmt == 2 { + w.w16(kept.len() as u16); + } + for e in &kept { + if !write_value_record(w, r, e.value_abs, value_format) { + return false; + } + } + let cov_gids: Vec = kept.iter().map(|e| e.new_gid).collect(); + let cov_pos = emit_coverage(w, &cov_gids); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + true +} + +/// PairPos 子表序列化(fmt1 glyph 对 / fmt2 class 对 + class 紧致重编号) +fn serialize_pair_pos(w: &mut Writer, ctx: &mut SubCtx, sub_abs: usize) -> bool { + let r = ctx.r; + let fmt = r.raw16(sub_abs); + let coverage_off = r.raw16(sub_abs + 2) as usize; + let value_format1 = r.raw16(sub_abs + 4); + let value_format2 = r.raw16(sub_abs + 6); + let vr1 = value_record_size(value_format1); + let vr2 = value_record_size(value_format2); + if value_format1 & VF_DEVICE_MASK != 0 || value_format2 & VF_DEVICE_MASK != 0 { + return false; + } + + if fmt == 1 { + let first_gids = read_coverage_gids(r, sub_abs + coverage_off); + let pair_set_count = r.raw16(sub_abs + 8) as usize; + + struct Rebuilt { + new_first: u16, + bytes: Vec, + } + let mut rebuilt: Vec = Vec::new(); + for idx in 0..pair_set_count { + if idx >= first_gids.len() { + continue; + } + let Some(new_first) = ctx.remap(u32::from(first_gids[idx])) else { + continue; + }; + let pair_set_off = sub_abs + r.raw16(sub_abs + 10 + idx * 2) as usize; + let pair_value_count = r.raw16(pair_set_off) as usize; + struct KeptSecond { + new_second: u16, + rec_abs: usize, + } + let mut kept_seconds: Vec = Vec::new(); + for p in 0..pair_value_count { + let rec_abs = pair_set_off + 2 + p * (2 + vr1 * 2 + vr2 * 2); + let Some(new_second) = ctx.remap(u32::from(r.raw16(rec_abs))) else { + continue; + }; + kept_seconds.push(KeptSecond { new_second, rec_abs }); + } + kept_seconds.sort_unstable_by_key(|k| k.new_second); + let mut pw = Writer::new(); + pw.w16(kept_seconds.len() as u16); + for ks in &kept_seconds { + pw.w16(ks.new_second); + if vr1 > 0 && !write_value_record(&mut pw, r, ks.rec_abs + 2, value_format1) { + return false; + } + if vr2 > 0 && !write_value_record(&mut pw, r, ks.rec_abs + 2 + vr1 * 2, value_format2) { + return false; + } + } + rebuilt.push(Rebuilt { new_first, bytes: pw.list }); + } + rebuilt.sort_unstable_by_key(|k| k.new_first); + + let sub_start = w.len(); + w.w16(1); + let cov_slot = w.len(); + w.w16(0); + w.w16(value_format1); + w.w16(value_format2); + w.w16(rebuilt.len() as u16); + let slot_base = w.len(); + for _ in 0..rebuilt.len() { + w.w16(0); + } + for (si, e) in rebuilt.iter().enumerate() { + let pos = w.len(); + w.wbytes(&e.bytes); + w.w16at(slot_base + si * 2, (pos - sub_start) as u16); + } + let cov_gids: Vec = rebuilt.iter().map(|e| e.new_first).collect(); + let cov_pos = emit_coverage(w, &cov_gids); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + return true; + } + + if fmt == 2 { + let class_def1_off = r.raw16(sub_abs + 8) as usize; + let class_def2_off = r.raw16(sub_abs + 10) as usize; + let class2_count = r.raw16(sub_abs + 14) as usize; + let gid_to_class1 = read_class_def_map(ctx, sub_abs + class_def1_off); + let gid_to_class2 = read_class_def_map(ctx, sub_abs + class_def2_off); + + // 实际命中的 class(class 0 恒保留),升序紧致重编号 + let mut used1: Vec = vec![0]; + for &c in gid_to_class1.values() { + if !used1.contains(&c) { + used1.push(c); + } + } + let mut used2: Vec = vec![0]; + for &c in gid_to_class2.values() { + if !used2.contains(&c) { + used2.push(c); + } + } + used1.sort_unstable(); + used2.sort_unstable(); + // 原 class → 紧致 class(升序重编号) + let c1_remap: HashMap = + used1.iter().enumerate().map(|(i, &c)| (c, i as u16)).collect(); + let c2_remap: HashMap = + used2.iter().enumerate().map(|(i, &c)| (c, i as u16)).collect(); + let new_class1_count = used1.len(); + let new_class2_count = used2.len(); + + // 紧致后的 ClassDef(新 gid -> 紧致 class) + let mut compact_cd1: HashMap = HashMap::with_capacity(gid_to_class1.len()); + for (&gid, &cls) in &gid_to_class1 { + // 单射反查:Zig 迭代找 value==nc 的 key 等价于 used 数组按下标取(紧致映射恒存在) + compact_cd1.insert(gid, c1_remap[&cls]); + } + let mut compact_cd2: HashMap = HashMap::with_capacity(gid_to_class2.len()); + for (&gid, &cls) in &gid_to_class2 { + compact_cd2.insert(gid, c2_remap[&cls]); + } + + // coverage 重映射(升序) + let cov_gids = read_coverage_gids(r, sub_abs + coverage_off); + let mut new_cov: Vec = Vec::new(); + for g in cov_gids { + if let Some(ng) = ctx.remap(u32::from(g)) { + new_cov.push(ng); + } + } + new_cov.sort_unstable(); + + let class2_rec_size = vr1 * 2 + vr2 * 2; + let sub_start = w.len(); + w.w16(2); + let cov_slot = w.len(); + w.w16(0); + w.w16(value_format1); + w.w16(value_format2); + let cd1_slot = w.len(); + w.w16(0); + let cd2_slot = w.len(); + w.w16(0); + w.w16(new_class1_count as u16); + w.w16(new_class2_count as u16); + + // class1Records:按紧致 class 遍历,从原始数组 (原class1 * class2Count + 原class2) 取值 + for nc1 in 0..new_class1_count { + // 原 class = used1 中第 nc1 个(升序重编号,直接查表) + let oc1 = used1[nc1]; + for nc2 in 0..new_class2_count { + let oc2 = used2[nc2]; + let rec_abs = sub_abs + 16 + (oc1 as usize * class2_count + oc2 as usize) * class2_rec_size; + if vr1 > 0 && !write_value_record(w, r, rec_abs, value_format1) { + return false; + } + if vr2 > 0 && !write_value_record(w, r, rec_abs + vr1 * 2, value_format2) { + return false; + } + } + } + + let cd1_pos = emit_class_def_from_class_map(w, &compact_cd1); + let cd2_pos = emit_class_def_from_class_map(w, &compact_cd2); + let cov_pos = emit_coverage(w, &new_cov); + w.w16at(cd1_slot, (cd1_pos - sub_start) as u16); + w.w16at(cd2_slot, (cd2_pos - sub_start) as u16); + w.w16at(cov_slot, (cov_pos - sub_start) as u16); + return true; + } + false +} + +/// GPOS 子集化入口(对应 TS subsetGPOS)。 +/// 返回重映射后的 GPOS 字节;版本不支持/解析异常/含 Device ValueRecord 时返回 None +/// (调用方保留原始 GPOS 字节——None = 透传原始字节,区别于错误)。 +pub fn subset_gpos(gpos_bytes: &[u8], keep: &[u16]) -> Result>, GsubError> { + let r = Reader::new(gpos_bytes); + let mut max_orig_gid: usize = 0; + for &g in keep { + if g as usize > max_orig_gid { + max_orig_gid = g as usize; + } + } + let mut gid_lookup = vec![-1i32; max_orig_gid + 1]; + for (new_gid, &g) in keep.iter().enumerate() { + gid_lookup[g as usize] = new_gid as i32; + } + // PairPos format2 的 ClassDef fmt2 读取(read_class_def_map)依赖升序原 gid 二分,必须填充; + // 曾传空导致 fmt2 class 全丢、类矩阵塌缩 1x1(PairPos2 kerning 全失,仅 CJK 全字 GPOS 暴露) + let mut sorted_subset = keep.to_vec(); + sorted_subset.sort_unstable(); + let mut ctx = SubCtx { r: &r, gid_lookup, sorted_subset, cov_cache: HashMap::new() }; + + // ---- Header:仅 v1.0 / v1.1(v1.1 的 FeatureVariations 非零不处理)---- + let major = r.raw16(0); + let minor = r.raw16(2); + if major != 1 || minor > 1 { + return Ok(None); + } + let script_list_off = r.raw16(4) as usize; + let feature_list_off = r.raw16(6) as usize; + let lookup_list_off = r.raw16(8) as usize; + if minor == 1 && r.rd32(10) != 0 { + return Ok(None); + } + + // ---- LookupList 解析(extension type9 解引用)---- + let lookup_count = r.raw16(lookup_list_off) as usize; + struct Lk { + supported: bool, + effective_type: i32, + sub_offs: Vec, + orig_off: usize, + } + let mut lookups: Vec = Vec::new(); + for li in 0..lookup_count { + let l_off = lookup_list_off + r.raw16(lookup_list_off + 2 + li * 2) as usize; + let lookup_type = r.raw16(l_off) as usize; + let sub_table_count = r.raw16(l_off + 4) as usize; + let mut sub_offs: Vec = Vec::new(); + let mut effective_type: i32 = lookup_type as i32; + for sj in 0..sub_table_count { + let sub_off = l_off + r.raw16(l_off + 6 + sj * 2) as usize; + if lookup_type == 9 { + if r.raw16(sub_off) != 1 { + effective_type = -1; + continue; + } + effective_type = i32::from(r.raw16(sub_off + 2)); + sub_offs.push(sub_off + r.rd32(sub_off + 4) as usize); + } else { + sub_offs.push(sub_off); + } + } + let supported = effective_type == 1 || effective_type == 2; + lookups.push(Lk { supported, effective_type, sub_offs, orig_off: l_off }); + } + + // 预扫描每 subtable coverage 命中(supported lookup) + let mut hits: Vec> = Vec::with_capacity(lookups.len()); + for lk in &lookups { + let mut h: Vec = Vec::new(); + if lk.supported { + for &so in &lk.sub_offs { + h.push(pos_subtable_coverage_hits(&ctx, so)); + } + } + hits.push(h); + } + + // ---- ScriptList / FeatureList(span 快路径 + 重序列化降级)---- + let sl_span = script_list_span(&r, script_list_off); + let sl_contiguous = sl_span >= 0 && script_list_off + sl_span as usize <= feature_list_off; + let script_list_bytes: Option> = if sl_contiguous { + Some(gpos_bytes[script_list_off..script_list_off + sl_span as usize].to_vec()) + } else { + serialize_script_list(&r, script_list_off) + }; + let fl_span = feature_list_span(&r, feature_list_off); + let fl_contiguous = fl_span >= 0 && feature_list_off + fl_span as usize <= lookup_list_off; + let feature_list_bytes: Option> = if fl_contiguous { + Some(gpos_bytes[feature_list_off..feature_list_off + fl_span as usize].to_vec()) + } else { + serialize_feature_list(&r, feature_list_off) + }; + r.clear_error(); + let (script_list_bytes, feature_list_bytes) = match (script_list_bytes, feature_list_bytes) { + (Some(sl), Some(fl)) => (sl, fl), + _ => return Ok(None), + }; + + // ---- 主 Writer + Header(版本恒写 1.0,与 TS 一致;按原表长度预分配)---- + let mut w = Writer::with_capacity(gpos_bytes.len()); + w.w16(1); + w.w16(0); + let sl_slot = w.len(); + w.w16(0); + let fl_slot = w.len(); + w.w16(0); + let ll_slot = w.len(); + w.w16(0); + + let sl_abs = w.len(); + w.wbytes(&script_list_bytes); + let fl_abs = w.len(); + w.wbytes(&feature_list_bytes); + + // ---- LookupList ---- + let ll_abs = w.len(); + w.w16(lookups.len() as u16); + let lookup_slots = w.len(); + for _ in 0..lookups.len() { + w.w16(0); + } + + for (i, lk) in lookups.iter().enumerate() { + let lookup_abs = w.len(); + let lookup_flag = r.rd16(lk.orig_off + 2); + let use_mark_filtering_set = (lookup_flag & 0x0010) != 0; + if lk.supported { + let any_hit = hits[i].iter().any(|&h| h); + // 输出 lookup 类型用 effectiveType(extension 解包后内嵌) + w.w16(lk.effective_type as u16); + w.w16(lookup_flag); + if !any_hit { + // 全空折叠:subCount=1 单个空 subtable + w.w16(1); + let lookup_start = w.len() - 6; + let subtable_slot = w.len(); + w.w16(0); + if use_mark_filtering_set { + w.w16(r.rd16(lk.orig_off + 6 + lk.sub_offs.len() * 2)); + } + let subtable_pos = w.len(); + write_empty_pos_subtable(&mut w, lk.effective_type); + w.w16at(subtable_slot, (subtable_pos - lookup_start) as u16); + } else { + // 只输出 coverage 命中的 subtable(未命中的必产出空表,渲染等价) + let mut kept: Vec = Vec::new(); + for (j, &h) in hits[i].iter().enumerate() { + if h { + kept.push(j); + } + } + w.w16(kept.len() as u16); + let lookup_start = w.len() - 6; + let subtable_slots = w.len(); + for _ in 0..kept.len() { + w.w16(0); + } + if use_mark_filtering_set { + w.w16(r.rd16(lk.orig_off + 6 + lk.sub_offs.len() * 2)); + } + for (j, &orig_idx) in kept.iter().enumerate() { + let before = w.len(); + r.clear_error(); + let ok = if lk.effective_type == 1 { + serialize_single_pos(&mut w, &mut ctx, lk.sub_offs[orig_idx]) + } else if lk.effective_type == 2 { + serialize_pair_pos(&mut w, &mut ctx, lk.sub_offs[orig_idx]) + } else { + false + }; + if !ok || r.error_flag.get() { + return Ok(None); + } + // Zig 的 indexOfScalar 在顺序遍历下恒等于循环下标 j + w.w16at(subtable_slots + j * 2, (before - lookup_start) as u16); + } + } + } else { + // unsupported lookup:保留原 type/flag,折叠 subCount=1 空表 + w.w16(r.rd16(lk.orig_off)); + w.w16(lookup_flag); + w.w16(1); + let lookup_start = w.len() - 6; + let subtable_slot = w.len(); + w.w16(0); + if use_mark_filtering_set { + w.w16(r.rd16(lk.orig_off + 6 + lk.sub_offs.len() * 2)); + } + let subtable_pos = w.len(); + write_empty_pos_subtable(&mut w, lk.effective_type); + w.w16at(subtable_slot, (subtable_pos - lookup_start) as u16); + } + w.w16at(lookup_slots + i * 2, (lookup_abs - ll_abs) as u16); + } + + w.w16at(sl_slot, sl_abs as u16); + w.w16at(fl_slot, fl_abs as u16); + w.w16at(ll_slot, ll_abs as u16); + + Ok(Some(w.list)) +} + +// ===== 测试 ===== + +#[cfg(test)] +mod tests { + use super::*; + + fn push_u16(out: &mut Vec, v: u16) { + out.extend_from_slice(&v.to_be_bytes()); + } + + fn be16(b: &[u8], off: usize) -> u16 { + u16::from_be_bytes([b[off], b[off + 1]]) + } + + /// 写 coverage format1(升序 gid 数组) + fn push_coverage1(out: &mut Vec, gids: &[u16]) { + push_u16(out, 1); + push_u16(out, gids.len() as u16); + for &g in gids { + push_u16(out, g); + } + } + + /// 组装最小合法 GSUB/GPOS 表(共用结构):Header + ScriptList(DFLT) + FeatureList(liga) + /// + LookupList。script/feature 列表与 Zig 版序列化产物布局一致(连续 span 快路径可命中)。 + fn build_layout_table(feature_lookups: &[u16], lookups: &[Vec]) -> Vec { + let mut script = Vec::new(); + push_u16(&mut script, 1); // scriptCount + script.extend_from_slice(b"DFLT"); + push_u16(&mut script, 8); // scriptOffset(相对 ScriptList) + push_u16(&mut script, 4); // defaultLangSysOff(相对 ScriptTable) + push_u16(&mut script, 0); // langSysCount + // LangSys @8 + push_u16(&mut script, 0); // lookupOrder + push_u16(&mut script, 0xFFFF); // requiredFeatureIndex + push_u16(&mut script, 1); // featureIndexCount + push_u16(&mut script, 0); // featureIndices[0] + + let mut feature = Vec::new(); + push_u16(&mut feature, 1); // featureCount + feature.extend_from_slice(b"liga"); + push_u16(&mut feature, 8); // featureOffset + // FeatureTable @8 + push_u16(&mut feature, 0); // featureParams + push_u16(&mut feature, feature_lookups.len() as u16); + for &li in feature_lookups { + push_u16(&mut feature, li); + } + + let n = lookups.len(); + let mut ll = Vec::new(); + push_u16(&mut ll, n as u16); + let mut off = 2 + 2 * n; + for lk in lookups { + push_u16(&mut ll, off as u16); + off += lk.len(); + } + for lk in lookups { + ll.extend_from_slice(lk); + } + + let fl_rel = 10 + script.len(); + let ll_rel = fl_rel + feature.len(); + let mut out = Vec::new(); + push_u16(&mut out, 1); // majorVersion + push_u16(&mut out, 0); // minorVersion + push_u16(&mut out, 10); // scriptListOffset + push_u16(&mut out, fl_rel as u16); + push_u16(&mut out, ll_rel as u16); + out.extend_from_slice(&script); + out.extend_from_slice(&feature); + out.extend_from_slice(&ll); + out + } + + /// 拼一个 Lookup 表体(type + flag=0 + subtableOffsets + subtables) + fn lookup_body(ltype: u16, subtables: &[Vec]) -> Vec { + let mut lk = Vec::new(); + push_u16(&mut lk, ltype); + push_u16(&mut lk, 0); // lookupFlag + push_u16(&mut lk, subtables.len() as u16); + let mut off = 6 + 2 * subtables.len(); + for st in subtables { + push_u16(&mut lk, off as u16); + off += st.len(); + } + for st in subtables { + lk.extend_from_slice(st); + } + lk + } + + /// SingleSubst format1 subtable(coverage + delta) + fn single_subst_fmt1(coverage: &[u16], delta: i16) -> Vec { + let mut st = Vec::new(); + push_u16(&mut st, 1); // format + push_u16(&mut st, 6); // coverageOffset + push_u16(&mut st, delta as u16); + push_coverage1(&mut st, coverage); + st + } + + /// MultipleSubst format1 subtable(coverage + sequence 数组) + fn multiple_subst_fmt1(coverage: &[u16], sequences: &[&[u16]]) -> Vec { + let mut st = Vec::new(); + let cov_len = 4 + 2 * coverage.len(); + push_u16(&mut st, 1); // format + push_u16(&mut st, (6 + 2 * sequences.len()) as u16); // coverageOffset + push_u16(&mut st, sequences.len() as u16); + // sequence 紧跟 coverage 之后 + let mut off = 6 + 2 * sequences.len() + cov_len; + for seq in sequences { + push_u16(&mut st, off as u16); // sequenceOffsets + off += 2 + 2 * seq.len(); + } + push_coverage1(&mut st, coverage); + for &seq in sequences { + push_u16(&mut st, seq.len() as u16); + for &g in seq { + push_u16(&mut st, g); + } + } + st + } + + /// SinglePos format2 subtable(coverage + valueFormat + valueRecords) + fn single_pos_fmt2(coverage: &[u16], values: &[u16]) -> Vec { + let mut st = Vec::new(); + push_u16(&mut st, 2); // format + push_u16(&mut st, (8 + 2 * values.len()) as u16); // coverageOffset(coverage 跟在 valueRecords 后) + push_u16(&mut st, 0x0004); // valueFormat: xAdvance only + push_u16(&mut st, values.len() as u16); + for &v in values { + push_u16(&mut st, v); + } + push_coverage1(&mut st, coverage); + st + } + + /// write_empty_subtable 的字节(type=2 版) + fn expected_empty_subtable() -> Vec { + let mut st = Vec::new(); + push_u16(&mut st, 1); + push_u16(&mut st, 6); + push_u16(&mut st, 0); + push_u16(&mut st, 1); + push_u16(&mut st, 0); + st + } + + /// 从 sfnt 字体提取表体(测试 fixture 用) + fn extract_table<'a>(data: &'a [u8], tag: &[u8; 4]) -> Option<&'a [u8]> { + if data.len() < 12 { + return None; + } + let n = be16(data, 4) as usize; + for i in 0..n { + let off = 12 + i * 16; + if off + 16 > data.len() { + return None; + } + if &data[off..off + 4] == tag { + let s = u32::from_be_bytes(data[off + 8..off + 12].try_into().unwrap()) as usize; + let l = u32::from_be_bytes(data[off + 12..off + 16].try_into().unwrap()) as usize; + if s + l <= data.len() { + return Some(&data[s..s + l]); + } + return None; + } + } + None + } + + // ---- Reader / Writer 基础 ---- + + #[test] + fn reader_bounds_and_writer_rollback() { + let data = [0x12, 0x34, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x05]; + let r = Reader::new(&data); + assert_eq!(r.rd16(0), 0x1234); + assert_eq!(r.rd16s(2), -2); + assert_eq!(r.rd32(4), 5); + assert!(!r.error_flag.get()); + assert_eq!(r.rd16(8), 0); // 越界(8+2 > 8)→ 0 + errorFlag + assert!(r.error_flag.get()); + r.clear_error(); + assert!(!r.error_flag.get()); + assert_eq!(r.raw16(8), 0); // raw 越界 → 0 不置 flag + assert!(!r.error_flag.get()); + + let mut w = Writer::new(); + w.w16(0x0102); + w.wbytes(&[0xAA, 0xBB]); + w.w16at(0, 0x0304); + assert_eq!(&w.list, &[0x03, 0x04, 0xAA, 0xBB]); + w.rollback(2); + assert_eq!(w.list, &[0x03, 0x04]); + assert_eq!(w.len(), 2); + } + + // ---- Coverage 读写 round-trip / format 选择 ---- + + #[test] + fn emit_coverage_format_choice_and_roundtrip() { + // [10..=15] 连续 6 个:rangeCount=1,1*6 < 6*2 → format2 + let mut w = Writer::new(); + let off = emit_coverage(&mut w, &[10, 11, 12, 13, 14, 15]); + assert_eq!(off, 0); + assert_eq!(be16(&w.list, 0), 2); // format 2 + assert_eq!(be16(&w.list, 2), 1); // rangeCount + assert_eq!(be16(&w.list, 4), 10); + assert_eq!(be16(&w.list, 6), 15); + assert_eq!(be16(&w.list, 8), 0); // startCoverageIndex + let r = Reader::new(&w.list); + assert_eq!(read_coverage_gids(&r, 0), vec![10, 11, 12, 13, 14, 15]); + + // [1,2,3] 连续 3 个:1*6 < 3*2 不成立(6<6 假)→ format1(精确字节判据边界) + let mut w = Writer::new(); + emit_coverage(&mut w, &[1, 2, 3]); + assert_eq!(be16(&w.list, 0), 1); + let r = Reader::new(&w.list); + assert_eq!(read_coverage_gids(&r, 0), vec![1, 2, 3]); + + // 离散数组 → format1 + let mut w = Writer::new(); + emit_coverage(&mut w, &[1, 5, 9]); + assert_eq!(be16(&w.list, 0), 1); + let r = Reader::new(&w.list); + assert_eq!(read_coverage_gids(&r, 0), vec![1, 5, 9]); + + // 空 coverage → format1 + count0 + let mut w = Writer::new(); + emit_coverage(&mut w, &[]); + assert_eq!(w.list, vec![0, 1, 0, 0]); + } + + #[test] + fn coverage_index_of_fmt1_fmt2() { + // format1 + let mut cov = Vec::new(); + push_coverage1(&mut cov, &[10, 20, 30]); + let r = Reader::new(&cov); + assert_eq!(coverage_index_of(&r, 0, 10), 0); + assert_eq!(coverage_index_of(&r, 0, 20), 1); + assert_eq!(coverage_index_of(&r, 0, 30), 2); + assert_eq!(coverage_index_of(&r, 0, 15), -1); + assert_eq!(coverage_index_of(&r, 0, 5), -1); + assert_eq!(coverage_index_of(&r, 0, 40), -1); + + // format2:ranges [(5,7),(10,12)] + let mut cov = Vec::new(); + push_u16(&mut cov, 2); + push_u16(&mut cov, 2); + push_u16(&mut cov, 5); + push_u16(&mut cov, 7); + push_u16(&mut cov, 0); + push_u16(&mut cov, 10); + push_u16(&mut cov, 12); + push_u16(&mut cov, 3); + let r = Reader::new(&cov); + assert_eq!(coverage_index_of(&r, 0, 5), 0); + assert_eq!(coverage_index_of(&r, 0, 6), 1); + assert_eq!(coverage_index_of(&r, 0, 7), 2); + assert_eq!(coverage_index_of(&r, 0, 10), 3); + assert_eq!(coverage_index_of(&r, 0, 12), 5); + assert_eq!(coverage_index_of(&r, 0, 8), -1); + assert_eq!(coverage_index_of(&r, 0, 4), -1); + assert_eq!(coverage_count(&r, 0), 6); + } + + // ---- collect_reachable ---- + + #[test] + fn collect_reachable_unsupported_version_returns_empty_vec() { + // 空 Vec ≠ 错误:版本不支持时退 seed 序 + let mut t = Vec::new(); + push_u16(&mut t, 2); // major=2 + push_u16(&mut t, 0); + t.extend_from_slice(&[0u8; 16]); + assert_eq!(collect_reachable(&t, &[1, 2]).unwrap(), Vec::::new()); + + // minor > 1 同样不支持 + let mut t2 = Vec::new(); + push_u16(&mut t2, 1); + push_u16(&mut t2, 2); + t2.extend_from_slice(&[0u8; 16]); + assert_eq!(collect_reachable(&t2, &[1]).unwrap(), Vec::::new()); + } + + #[test] + fn collect_reachable_single_subst_chain() { + // coverage [1,2],delta +1:1→2→3(3 不在 coverage,闭合) + let t = build_layout_table(&[0], &[lookup_body(1, &[single_subst_fmt1(&[1, 2], 1)])]); + assert_eq!(collect_reachable(&t, &[1]).unwrap(), vec![1, 2, 3]); + // 种子顺序 = 插入序 + assert_eq!(collect_reachable(&t, &[2, 1]).unwrap(), vec![2, 1, 3]); + // 空种子 → 空 Vec(非错误) + assert_eq!(collect_reachable(&t, &[]).unwrap(), Vec::::new()); + } + + // ---- subset_gsub ---- + + #[test] + fn subset_gsub_unsupported_version_passthrough() { + let mut t = Vec::new(); + push_u16(&mut t, 2); + push_u16(&mut t, 0); + t.extend_from_slice(&[0xAB; 16]); + let out = subset_gsub(&t, &[0, 1]).unwrap(); + assert_eq!(out, t); // 原样返回 + } + + #[test] + fn subset_gsub_single_subst_identity_keep_is_byte_identical() { + let t = build_layout_table(&[0], &[lookup_body(1, &[single_subst_fmt1(&[1, 2], 1)])]); + // keep = [0,1,2,3] 恒等映射:输出应与输入逐字节相同 + let out = subset_gsub(&t, &[0, 1, 2, 3]).unwrap(); + assert_eq!(out, t); + } + + #[test] + fn subset_gsub_single_subst_remap_insertion_order() { + let t = build_layout_table(&[0], &[lookup_body(1, &[single_subst_fmt1(&[1, 2], 1)])]); + // keep 插入序 [0,5,1,2]:新 gid 5→1, 1→2, 2→3 + // orig1→2 重映射为 2→3(保留);orig2→3 中 3 不在子集 → 丢弃 + // 剩余 entry (2,3) 统一 delta=1 → format1,coverage [2] + let mut sub = Vec::new(); + push_u16(&mut sub, 1); + push_u16(&mut sub, 6); + push_u16(&mut sub, 1); + push_coverage1(&mut sub, &[2]); + let expected = build_layout_table(&[0], &[lookup_body(1, &[sub])]); + let out = subset_gsub(&t, &[0, 5, 1, 2]).unwrap(); + assert_eq!(out, expected); + } + + #[test] + fn subset_gsub_multiple_subst_remap_and_sort() { + // coverage [1,2];seq(1)=[3,4],seq(2)=[5] + let t = build_layout_table( + &[0], + &[lookup_body(2, &[multiple_subst_fmt1(&[1, 2], &[&[3, 4], &[5]])])], + ); + // keep [0,1,2,3,5]:新 gid 1→1,2→2,3→3,5→4;4 不在子集 → seq(1) 去掉 4 + // entries 排序后:(1,[3]),(2,[4]) + let mut sub = Vec::new(); + push_u16(&mut sub, 1); // format + push_u16(&mut sub, 10); // coverageOffset(6 + 2*2) + push_u16(&mut sub, 2); // sequenceCount + push_u16(&mut sub, 18); // seqOffsets[0](coverage [1,2] 占 8 字节,seq 紧随其后) + push_u16(&mut sub, 22); // seqOffsets[1] + push_coverage1(&mut sub, &[1, 2]); // @10 + push_u16(&mut sub, 1); // seq(1) glyphCount + push_u16(&mut sub, 3); + push_u16(&mut sub, 1); // seq(2) glyphCount + push_u16(&mut sub, 4); + let expected = build_layout_table(&[0], &[lookup_body(2, &[sub])]); + let out = subset_gsub(&t, &[0, 1, 2, 3, 5]).unwrap(); + assert_eq!(out, expected); + } + + #[test] + fn subset_gsub_all_empty_lookup_folds_to_single_empty_subtable() { + // coverage [7] 全不在 keep → allEmpty 折叠 subCount=1 空表 + let t = build_layout_table(&[0], &[lookup_body(2, &[multiple_subst_fmt1(&[7], &[&[3, 4]])])]); + let expected = build_layout_table(&[0], &[lookup_body(2, &[expected_empty_subtable()])]); + let out = subset_gsub(&t, &[0, 1, 2]).unwrap(); + assert_eq!(out, expected); + } + + #[test] + fn subset_gsub_empty_keep_still_valid() { + let t = build_layout_table(&[0], &[lookup_body(1, &[single_subst_fmt1(&[1, 2], 1)])]); + let out = subset_gsub(&t, &[]).unwrap(); + // 全空折叠:major=1、lookup 数不变 + assert_eq!(be16(&out, 0), 1); + let ll = be16(&out, 8) as usize; + assert_eq!(be16(&out, ll), 1); + } + + // ---- subset_gpos ---- + + #[test] + fn subset_gpos_unsupported_version_returns_none() { + let mut t = Vec::new(); + push_u16(&mut t, 2); + push_u16(&mut t, 0); + t.extend_from_slice(&[0u8; 16]); + assert_eq!(subset_gpos(&t, &[0, 1]).unwrap(), None); // None = 透传原始字节 + } + + #[test] + fn subset_gpos_single_pos_fmt2_remap_and_sort() { + let t = build_layout_table(&[0], &[lookup_body(1, &[single_pos_fmt2(&[1, 2], &[100, 200])])]); + // keep 插入序 [0,2,1]:新 gid 2→1, 1→2 + // kept 按 new_gid 升序:new1←orig2(val200@sub+10)、new2←orig1(val100@sub+8) + let mut sub = Vec::new(); + push_u16(&mut sub, 2); // format + push_u16(&mut sub, 12); // coverageOffset(8 + 2*2:coverage 跟在 valueRecords 后) + push_u16(&mut sub, 0x0004); // valueFormat + push_u16(&mut sub, 2); // valueCount + push_u16(&mut sub, 200); + push_u16(&mut sub, 100); + push_coverage1(&mut sub, &[1, 2]); + let expected = build_layout_table(&[0], &[lookup_body(1, &[sub])]); + let out = subset_gpos(&t, &[0, 2, 1]).unwrap().expect("Some"); + assert_eq!(out, expected); + } + + #[test] + fn subset_gpos_all_miss_folds_and_none_semantics() { + // coverage [7] 不在 keep → 全空折叠空 Position subtable + let t = build_layout_table(&[0], &[lookup_body(1, &[single_pos_fmt2(&[7], &[42])])]); + let mut sub = Vec::new(); + push_u16(&mut sub, 1); // SinglePos fmt1 形态空表 + push_u16(&mut sub, 6); // coverageOff + push_u16(&mut sub, 0); // valueFormat = 0 + push_coverage1(&mut sub, &[]); + let expected = build_layout_table(&[0], &[lookup_body(1, &[sub])]); + let out = subset_gpos(&t, &[0, 1, 2]).unwrap().expect("Some"); + assert_eq!(out, expected); + } + + // ---- 真实字体(思源黑体)冒烟 ---- + + #[test] + fn real_font_source_han_gsub_gpos_smoke() { + // cargo test 工作目录 = rust-spike/(与 ttf::tests 的 TEST_FONT 同一约定) + let data = std::fs::read("../font/思源黑体.ttf").expect("read font"); + let gsub_tbl = extract_table(&data, b"GSUB").expect("GSUB table"); + // 多组种子(含大 gid):可达闭包非空且含全部种子(插入序前置) + for seeds in [&[0u16][..], &[0, 10, 100, 500, 1000][..], &[0, 30000, 60000][..]] { + let reachable = collect_reachable(gsub_tbl, seeds).unwrap(); + assert!(!reachable.is_empty()); + for &s in seeds { + assert!(reachable.contains(&s)); + } + // 种子位于插入序头部(各种子按序出现) + let mut last = 0usize; + for &s in seeds { + let pos = reachable.iter().position(|&g| g == s).unwrap(); + assert!(pos >= last); + last = pos; + } + // 子集化:keep 用可达闭包本身(插入序),输出结构可解析 + let out = subset_gsub(gsub_tbl, &reachable).unwrap(); + assert_eq!(be16(&out, 0), 1); // majorVersion + assert!(be16(&out, 2) <= 1); // minorVersion + // ScriptList script 数与原表一致(ScriptList 重建保真) + assert_eq!(be16(&out, 4) as usize, 10); + let sl = be16(&out, 4) as usize; + assert_eq!(be16(&out, sl), be16(gsub_tbl, be16(gsub_tbl, 4) as usize)); + // LookupList lookup 数一致(不删 lookup 红线) + let ll = be16(&out, 8) as usize; + let orig_ll = be16(gsub_tbl, 8) as usize; + assert_eq!(be16(&out, ll), be16(gsub_tbl, orig_ll)); + + // 再用小 keep(前 16 个)跑一次小子集路径 + let small = &reachable[..reachable.len().min(16)]; + let out2 = subset_gsub(gsub_tbl, small).unwrap(); + assert_eq!(be16(&out2, 0), 1); + } + + // GPOS:Ok(Some) 或 Ok(None) 均合法(None = 透传),但不得 Err + if let Some(gpos_tbl) = extract_table(&data, b"GPOS") { + let reachable = collect_reachable(gsub_tbl, &[0, 10, 100, 500]).unwrap(); + let keep = if reachable.is_empty() { vec![0u16] } else { reachable }; + let r = subset_gpos(gpos_tbl, &keep); + assert!(r.is_ok()); + if let Ok(Some(out)) = r { + assert_eq!(be16(&out, 0), 1); + assert_eq!(be16(&out, 2), 0); // 版本恒写 1.0 + } + } + } +} diff --git a/rust-spike/src/http.rs b/rust-spike/src/http.rs new file mode 100644 index 0000000..937674a --- /dev/null +++ b/rust-spike/src/http.rs @@ -0,0 +1,193 @@ +//! HTTP 响应辅助(对译 zig-spike/src/main.zig 的 sendText/sendFont/sendJson/writeAll/urlDecode) +//! CORS 三头追加语义对齐 backend/app.ts corsMiddleware(OPTIONS 204 例外不带 CORS 头) + +use std::io::{self, IoSlice, Write}; +use std::net::TcpStream; + +/// CORS 三头(顺序对齐 Zig 版,逐头追加) +const CORS: [&str; 3] = [ + "Access-Control-Allow-Origin: *", + "Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS", + "Access-Control-Allow-Headers: Content-Type, Authorization", +]; + +/// 连接关闭头 +fn conn_header(close: bool) -> &'static str { + if close { "close" } else { "keep-alive" } +} + +/// iovec 式写出:write_vectored 单次系统调用(对齐 Zig writeAll 单次 net_write 的意图); +/// 各段零拷贝(IoSlice 借用),部分写时循环补发剩余区间 +pub fn write_all(stream: &mut TcpStream, parts: &[&[u8]]) -> io::Result<()> { + let mut slices: Vec = parts.iter().map(|p| IoSlice::new(p)).collect(); + let mut total: usize = slices.iter().map(|s| s.len()).sum(); + while total > 0 { + let n = stream.write_vectored(&slices)?; + if n == 0 { + return Err(io::Error::new(io::ErrorKind::WriteZero, "write_vectored 写入 0 字节")); + } + total -= n; + let mut rem = n; + for s in slices.iter_mut() { + let len = s.len(); + if rem >= len { + rem -= len; + } else { + s.advance(rem); + break; + } + } + slices.retain(|s| !s.is_empty()); + } + Ok(()) +} + +/// FNV-1a 64 字节哈希 → 强 ETag("\"16hex\"") +pub fn etag_of(bytes: &[u8]) -> String { + let mut h: u64 = 0xcbf29ce484222325; + for &b in bytes { + h ^= b as u64; + h = h.wrapping_mul(0x100000001b3); + } + format!("\"{h:016x}\"") +} + +/// 纯文本响应(extra 可挂额外头如 Retry-After) +pub fn send_text( + stream: &mut TcpStream, + code: u16, + body: &str, + close: bool, + extra: &[&str], +) -> io::Result<()> { + let mut head = String::with_capacity(256 + body.len()); + head.push_str(&format!( + "HTTP/1.1 {code} X\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: {}\r\n", + body.len() + )); + for h in extra { + head.push_str(h); + head.push_str("\r\n"); + } + for h in CORS { + head.push_str(h); + head.push_str("\r\n"); + } + head.push_str(&format!("Connection: {}\r\n\r\n", conn_header(close))); + write_all(stream, &[head.as_bytes(), body.as_bytes()]) +} + +#[allow(dead_code)] // R5' 路由接入前未用 +/// JSON 错误响应(格式对齐 TS jsonResponse:application/json) +pub fn send_json(stream: &mut TcpStream, code: u16, body: &str, close: bool) -> io::Result<()> { + let head = format!( + "HTTP/1.1 {code} X\r\nContent-Type: application/json\r\nContent-Length: {}\r\n", + body.len() + ); + let mut head = head; + for h in CORS { + head.push_str(h); + head.push_str("\r\n"); + } + head.push_str(&format!("Connection: {}\r\n\r\n", conn_header(close))); + write_all(stream, &[head.as_bytes(), body.as_bytes()]) +} + +/// 字体成功响应(强缓存 max-age=86400 + ETag 兜底;命中 If-None-Match 回 304 零字节) +/// 背景:字体子集内容不变,24h 强缓存使浏览器零回源;服务端字节变化靠 ETag 在协商时自愈 +pub fn send_font( + stream: &mut TcpStream, + bytes: &[u8], + close: bool, + content_type: &str, + extra: &[&str], + timing: &[&str], + etag: &str, + if_none_match: Option<&str>, +) -> io::Result<()> { + // 弱 ETag 匹配(W/"x" 与 "x" 都认) + let matched = if_none_match.is_some_and(|v| { + v.split(',').any(|t| { + let t = t.trim(); + t == etag + || t == format!("W/{etag}") + || (t.starts_with("W/") && &t[2..] == etag) + }) + }); + if matched { + let head = format!( + "HTTP/1.1 304 Not Modified\r\nContent-Length: 0\r\nCache-Control: public, max-age=86400\r\nETag: {etag}\r\n" + ); + let mut head = head; + for h in timing.iter() { + head.push_str(h); + head.push_str("\r\n"); + } + head.push_str(&format!("Connection: {}\r\n\r\n", conn_header(close))); + return write_all(stream, &[head.as_bytes()]); + } + let mut head = format!( + "HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nCache-Control: public, max-age=86400\r\nETag: {etag}\r\n", + bytes.len() + ); + for h in extra.iter().chain(timing.iter()) { + head.push_str(h); + head.push_str("\r\n"); + } + for h in CORS { + head.push_str(h); + head.push_str("\r\n"); + } + head.push_str(&format!("Connection: {}\r\n\r\n", conn_header(close))); + write_all(stream, &[head.as_bytes(), bytes]) +} + +/// OPTIONS 预检 204(corsMiddleware 分支:无 CORS 头) +pub fn send_options(stream: &mut TcpStream, close: bool) -> io::Result<()> { + let head = format!( + "HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: {}\r\n\r\n", + conn_header(close) + ); + write_all(stream, &[head.as_bytes()]) +} + +/// URL 解码(对译 Zig urlDecode:%XX 十六进制 + '+'→空格;非法序列原样保留) +pub fn url_decode(s: &str) -> Vec { + let b = s.as_bytes(); + let mut out = Vec::with_capacity(b.len()); + let mut i = 0; + while i < b.len() { + if b[i] == b'%' && i + 2 < b.len() { + let hi = (b[i + 1] as char).to_digit(16); + let lo = (b[i + 2] as char).to_digit(16); + match (hi, lo) { + (Some(h), Some(l)) => { + out.push((h * 16 + l) as u8); + i += 3; + } + _ => { + out.push(b[i]); + i += 1; + } + } + } else if b[i] == b'+' { out.push(b' '); + i += 1; + } else { + out.push(b[i]); + i += 1; + } + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn url_decode_basic() { + assert_eq!(url_decode("%E5%AD%97%E4%BD%93"), "字体".as_bytes()); + assert_eq!(url_decode("a+b"), b"a b"); + assert_eq!(url_decode("100%"), b"100%"); // 截断的 % 原样保留 + } +} diff --git a/rust-spike/src/main.rs b/rust-spike/src/main.rs new file mode 100644 index 0000000..9bb3080 --- /dev/null +++ b/rust-spike/src/main.rs @@ -0,0 +1,650 @@ +//! webfont-rs spike:HTTP 服务 + TTF 子集化(对译 zig-spike/src/main.zig) +//! 用法:PORT=8090 FONT_DIR=../font ./webfont-rs +//! webfont-rs bench [iters] (纯计算微基准,输出 checksum 防 DCE) +//! +//! 语义对齐 backend/routes/subset.ts(缓存/响应头/错误码),以 zig-spike 版为第二 oracle。 + +mod cache; +mod cff; +mod glyph_match; +mod gsub; +mod http; +mod misc; +mod ttf; +mod woff2; + +use std::io::Read; +use std::net::TcpListener; +use std::time::Instant; + +use cache::{FontCache, SubsetCache, DEFAULT_SUBSET_CACHE_MAX_BYTES}; + +/// 字体目录列表(启动时确定):FONT_DIRS(冒号分隔)> FONT_DIR(单目录)> TS 默认三目录 +const DEFAULT_FONT_DIRS: [&str; 3] = ["font/admin", "font", "font/temp"]; + +/// 共享服务状态 +struct App { + font_dirs: Vec, + fonts: FontCache, + subset_cache: SubsetCache, +} + +fn main() { + let args: Vec = std::env::args().collect(); + if args.len() > 1 { + match args[1].as_str() { + "bench" => return run_bench(&args[2..]), + "alloc-stats" => return run_alloc_stats(&args[2..]), + other => { + eprintln!("未知子命令: {other}(可用: bench, alloc-stats)"); + std::process::exit(2); + } + } + } + run_server(); +} + +/// 计数分配器:wrap System 累加分配/释放次数与字节(alloc-stats 诊断用) +struct CountingAlloc; + +use std::alloc::{GlobalAlloc, Layout, System}; +use std::sync::atomic::{AtomicUsize, Ordering}; + +static ALLOC_N: AtomicUsize = AtomicUsize::new(0); +static ALLOC_B: AtomicUsize = AtomicUsize::new(0); +static REALLOC_N: AtomicUsize = AtomicUsize::new(0); +static REALLOC_B: AtomicUsize = AtomicUsize::new(0); +static DEALLOC_N: AtomicUsize = AtomicUsize::new(0); + +unsafe impl GlobalAlloc for CountingAlloc { + unsafe fn alloc(&self, l: Layout) -> *mut u8 { + ALLOC_N.fetch_add(1, Ordering::Relaxed); + ALLOC_B.fetch_add(l.size(), Ordering::Relaxed); + unsafe { System.alloc(l) } + } + unsafe fn dealloc(&self, p: *mut u8, l: Layout) { + DEALLOC_N.fetch_add(1, Ordering::Relaxed); + unsafe { System.dealloc(p, l) } + } + unsafe fn realloc(&self, p: *mut u8, l: Layout, n: usize) -> *mut u8 { + REALLOC_N.fetch_add(1, Ordering::Relaxed); + REALLOC_B.fetch_add(n.saturating_sub(l.size()), Ordering::Relaxed); + unsafe { System.realloc(p, l, n) } + } + unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 { + ALLOC_N.fetch_add(1, Ordering::Relaxed); + ALLOC_B.fetch_add(l.size(), Ordering::Relaxed); + unsafe { System.alloc_zeroed(l) } + } +} + +#[global_allocator] +static GLOBAL_ALLOC: CountingAlloc = CountingAlloc; + +/// 诊断子命令:统计稳态单次 subset 的分配次数与字节量(性能优化期工具) +fn run_alloc_stats(args: &[String]) { + let (font_path, text, iters) = match args { + [f, t] => (f.as_str(), t.as_str(), 100usize), + [f, t, i] => (f.as_str(), t.as_str(), i.parse().unwrap_or(100)), + _ => { + eprintln!("用法: webfont-rs alloc-stats [iters]"); + std::process::exit(2); + } + }; + let data = std::fs::read(font_path).expect("read font"); + let font = ttf::Font::parse(data).expect("parse"); + for _ in 0..20 { + let _ = ttf::subset(&font, text).expect("subset"); + } + ALLOC_N.store(0, Ordering::Relaxed); + ALLOC_B.store(0, Ordering::Relaxed); + REALLOC_N.store(0, Ordering::Relaxed); + REALLOC_B.store(0, Ordering::Relaxed); + DEALLOC_N.store(0, Ordering::Relaxed); + for _ in 0..iters { + let _ = ttf::subset(&font, text).expect("subset"); + } + let it = iters as f64; + eprintln!( + "alloc: {:.1} 次/迭代, {:.0}B/迭代 | realloc: {:.1} 次/迭代, 搬移+{:.0}B/迭代 | dealloc: {:.1} 次/迭代", + ALLOC_N.load(Ordering::Relaxed) as f64 / it, + ALLOC_B.load(Ordering::Relaxed) as f64 / it, + REALLOC_N.load(Ordering::Relaxed) as f64 / it, + REALLOC_B.load(Ordering::Relaxed) as f64 / it, + DEALLOC_N.load(Ordering::Relaxed) as f64 / it, + ); +} + +fn run_server() { + let port: u16 = std::env::var("PORT").ok().and_then(|p| p.parse().ok()).unwrap_or(8090); + let font_dirs = resolve_font_dirs(); + let subset_max: usize = std::env::var("SUBSET_CACHE_MAX_SIZE") + .ok() + .and_then(|s| s.parse().ok()) + .unwrap_or(DEFAULT_SUBSET_CACHE_MAX_BYTES); + + let app = std::sync::Arc::new(App { + font_dirs, + fonts: FontCache::new(), + subset_cache: SubsetCache::new(subset_max), + }); + + // misc 初始化(配置解析/统计恢复/目录创建/后台线程,对齐 zig misc.init 在 listen 之前) + misc::init(); + + let listener = TcpListener::bind(("0.0.0.0", port)).expect("bind"); + let dirs = app.font_dirs.join(":"); + eprintln!("webfont-rs listening on {port}, font_dirs={dirs}"); + + for stream in listener.incoming() { + let Ok(stream) = stream else { continue }; + let app = app.clone(); + // 每连接一线程:keep-alive 长连接不阻塞其他客户端(对齐 Zig connThread 模型) + std::thread::spawn(move || { + let _ = conn_loop(&app, stream); + }); + } +} + +/// 解析字体目录配置(优先级:FONT_DIRS > FONT_DIR > 默认三目录) +fn resolve_font_dirs() -> Vec { + if let Ok(s) = std::env::var("FONT_DIRS") { + let list: Vec = s.split(':').filter(|d| !d.is_empty()).map(String::from).collect(); + if !list.is_empty() { + return list; + } + } + if let Ok(d) = std::env::var("FONT_DIR") { + return vec![d]; + } + DEFAULT_FONT_DIRS.iter().map(|s| s.to_string()).collect() +} + +/// 请求行 + 头解析结果 +struct Request<'a> { + method: &'a str, + path: &'a str, + query: &'a str, + body: &'a [u8], + close: bool, + /// If-None-Match 请求头(协商缓存 304 判定) + if_none_match: Option, +} + +/// 连接线程主体:keep-alive 循环,按 Content-Length 完整取帧后处理(对译 connThread/extractFrame) +fn conn_loop(app: &App, mut stream: std::net::TcpStream) -> std::io::Result<()> { + let mut buf: Vec = Vec::with_capacity(16 * 1024); + let mut rbuf = [0u8; 16 * 1024]; + loop { + if let Some(total) = extract_frame(&buf) { + let req_bytes = &buf[..total]; + let close = process_request(app, &mut stream, req_bytes)?; + // 移除已消费字节(剩余是下一请求的开头) + buf.drain(..total); + if close { + return Ok(()); + } + continue; + } + if buf.len() > 1024 * 1024 { + let _ = http::send_text(&mut stream, 400, "request too large", true, &[]); + return Ok(()); + } + let n = stream.read(&mut rbuf)?; + if n == 0 { + return Ok(()); // 客户端关闭 + } + buf.extend_from_slice(&rbuf[..n]); + } +} + +/// 判定缓冲里是否有完整请求帧(头结束 + Content-Length 全 body);无则 None(继续等读) +fn extract_frame(req: &[u8]) -> Option { + let hdr_end = find(req, b"\r\n\r\n")?; + let head = &req[..hdr_end]; + let mut content_length = 0usize; + for h in head.split(|&b| b == b'\n') { + let h = trim_cr(h); + let Some(colon) = h.iter().position(|&b| b == b':') else { continue }; + let name = &h[..colon]; + if !name.eq_ignore_ascii_case(b"content-length") { + continue; + } + let mut v = &h[colon + 1..]; + while let Some(&f) = v.first() { + if f == b' ' || f == b'\t' { v = &v[1..]; } else { break; } + } + content_length = std::str::from_utf8(v).ok()?.trim().parse().unwrap_or(0); + break; + } + let total = hdr_end + 4 + content_length; + if req.len() < total { + return None; + } + Some(total) +} + +fn find(haystack: &[u8], needle: &[u8]) -> Option { + haystack.windows(needle.len()).position(|w| w == needle) +} + +fn trim_cr(h: &[u8]) -> &[u8] { + match h.last() { + Some(&b'\r') => &h[..h.len() - 1], + _ => h, + } +} + +/// 解析请求行 + 头(对译 parseRequest + headerWantsClose) +fn parse_request(req: &[u8]) -> Option> { + let line_end = find(req, b"\r\n")?; + let line = &req[..line_end]; + let sp1 = line.iter().position(|&b| b == b' ')?; + let method = &line[..sp1]; + let rest = &line[sp1 + 1..]; + let rest = &rest[rest.iter().position(|&b| b != b' ').unwrap_or(rest.len())..]; + let sp2 = rest.iter().rposition(|&b| b == b' ')?; + let target = &rest[..sp2]; + let qpos = target.iter().position(|&b| b == b'?'); + let (path, query) = match qpos { + Some(q) => (&target[..q], &target[q + 1..]), + None => (target, &target[target.len()..]), + }; + let close = header_wants_close(req); + let hdr_end = find(req, b"\r\n\r\n")?; + let if_none_match = header_value(req, b"if-none-match") + .and_then(|v| String::from_utf8(v.to_vec()).ok()); + Some(Request { + if_none_match, + method: std::str::from_utf8(method).ok()?, + path: std::str::from_utf8(path).ok()?, + query: std::str::from_utf8(query).ok()?, + body: &req[hdr_end + 4..], + close, + }) +} + +/// 扫描请求头取指定头的值(大小写不敏感;找不到返 None) +fn header_value<'a>(req: &'a [u8], name: &[u8]) -> Option<&'a [u8]> { + for h in req.split(|&b| b == b'\n') { + let h = trim_cr(h); + if h.is_empty() { + break; + } + let Some(colon) = h.iter().position(|&b| b == b':') else { continue }; + if !h[..colon].eq_ignore_ascii_case(name) { + continue; + } + let mut v = &h[colon + 1..]; + while let Some(&f) = v.first() { + if f == b' ' || f == b'\t' { v = &v[1..]; } else { break; } + } + return Some(v); + } + None +} + +/// 扫描请求头是否 Connection: close +fn header_wants_close(req: &[u8]) -> bool { + for h in req.split(|&b| b == b'\n') { + let h = trim_cr(h); + if h.is_empty() { + break; // 空行 = 头结束 + } + let Some(colon) = h.iter().position(|&b| b == b':') else { continue }; + if !h[..colon].eq_ignore_ascii_case(b"connection") { + continue; + } + let mut v = &h[colon + 1..]; + while let Some(&f) = v.first() { + if f == b' ' || f == b'\t' { v = &v[1..]; } else { break; } + } + return v.eq_ignore_ascii_case(b"close"); + } + false +} + +/// 处理单个请求,返回 true 表示应关闭连接(对译 processRequest + routeRequest) +fn process_request(app: &App, stream: &mut std::net::TcpStream, req_bytes: &[u8]) -> std::io::Result { + let Some(r) = parse_request(req_bytes) else { + http::send_text(stream, 400, "bad request", true, &[])?; + return Ok(true); + }; + let close = r.close; + let t0 = Instant::now(); + + // 日志中间件 + 总请求计数(对齐 logMiddleware:响应后打印 [Nms] METHOD path) + misc::stats_total_request(); + let out_close = route_request(app, stream, req_bytes, &r, close)?; + + // 日志中间件(对齐 logMiddleware:响应后打印 [Nms] METHOD path) + eprintln!("[{}ms] {} {}", t0.elapsed().as_millis(), r.method, r.path); + Ok(out_close) +} + +/// 统一路由表(对齐 zig routeRequest:app.ts fontApiMiddleware + 静态资源中间件的兜底顺序) +fn route_request( + app: &App, + stream: &mut std::net::TcpStream, + req_bytes: &[u8], + r: &Request<'_>, + close: bool, +) -> std::io::Result { + // CORS 预检(corsMiddleware 的 OPTIONS 分支:204 + Content-Length: 0,无 CORS 头) + if r.method == "OPTIONS" { + http::send_options(stream, close)?; + return Ok(close); + } + let is_get = r.method == "GET"; + let is_post = r.method == "POST"; + + if r.path == "/api/fonts" && is_get { + return misc::handle_list_fonts(stream, &app.font_dirs, close); + } + if r.path == "/api/config" && is_get { + return misc::handle_get_config(stream, close); + } + if r.path == "/api/stats" && is_get { + return misc::handle_stats(stream, close, app.subset_cache.len(), app.fonts.len()); + } + if r.path == "/api/stats/event" && is_post { + return misc::handle_stats_event(stream, r.body, close); + } + if r.path == "/api/upload" && is_post { + return misc::handle_upload(stream, req_bytes, r.query, r.body, close); + } + if r.path == "/api/font-meta" && is_get { + return misc::handle_font_meta(stream, &app.font_dirs, r.query, close); + } + if r.path == "/api" && is_get { + return handle_subset(app, stream, r.query, close, r.if_none_match.as_deref()); + } + if r.path == "/api/glyph-match" && is_post { + return misc::handle_glyph_match(stream, &app.font_dirs, &app.fonts, r.body, close); + } + + // 未匹配路由 → 静态资源中间件(GET 走 dist/SSR/SPA fallback,非 GET 405) + misc::handle_static(stream, &app.font_dirs, r.method, r.path, close) +} + +/// GET /api?font=..&text=..&outType=.. —— 字体裁剪(对译 handleSubset,语义对齐 backend/routes/subset.ts) +fn handle_subset( + app: &App, + stream: &mut std::net::TcpStream, + query: &str, + close: bool, + if_none_match: Option<&str>, +) -> std::io::Result { + let t0 = Instant::now(); + let mut font_name: Vec = Vec::new(); + let mut text: Vec = Vec::new(); + let mut out_woff2 = false; + for kv in query.split('&') { + let Some(eq) = kv.find('=') else { continue }; + let (k, v) = (&kv[..eq], &kv[eq + 1..]); + match k { + "font" => font_name = http::url_decode(v), + "text" => text = http::url_decode(v), + "outType" if v == "woff2" => out_woff2 = true, + _ => {} + } + } + let Ok(font_name) = std::str::from_utf8(&font_name) else { + http::send_text(stream, 400, "bad font", close, &[])?; + return Ok(close); + }; + // TS 语义:text 为空时不响应(框架原样透传 res,连接挂起);Rust 收线等价安全 + if text.is_empty() { + return Ok(true); + } + // 路径穿越防护(Zig 额外加固;TS 无此拦截) + if font_name.contains("..") { + http::send_text(stream, 400, "bad font", close, &[])?; + return Ok(close); + } + let Ok(text) = std::str::from_utf8(&text) else { + http::send_text(stream, 400, "bad text", close, &[])?; + return Ok(close); + }; + let Some(font_path) = find_font_path(&app.font_dirs, font_name) else { + let msg = format!("Font not found: {font_name}"); + http::send_text(stream, 404, &msg, close, &[])?; + return Ok(close); + }; + let t1 = Instant::now(); + + // 记录字体被使用(临时字体保留机制)+ 子集化计数(对齐 subset.ts 顺序) + misc::mark_font_used(&font_path); + misc::stats_record_subset(misc::utf16_len_utf8(text)); + + // 查询裁剪结果缓存(key 对齐 TS:fontPath:outType:text) + let cache_key = format!( + "{font_path}:{}:{text}", + if out_woff2 { "woff2" } else { "ttf" } + ); + if let Some(bytes) = app.subset_cache.get(&cache_key) { + misc::stats_record_cache_hit(); + let t_hit = Instant::now(); + let timing = [format!("X-Timing-Total: {}", ms(t0, t_hit))]; + let timing: Vec<&str> = timing.iter().map(|s| s.as_str()).collect(); + let etag = http::etag_of(&bytes); + http::send_font( + stream, + &bytes, + close, + if out_woff2 { "font/woff2" } else { "font/ttf" }, + &["X-Cache: HIT"], + &timing, + &etag, + if_none_match, + )?; + return Ok(close); + } + + // 内存闸门:完整字体读取和裁剪都在闸门内;缓存命中不占槽位(对齐 subset.ts) + let est = misc::estimate_subset_memory(&font_path); + if !misc::gate_acquire(misc::queue_timeout_ms(), est) { + http::send_text(stream, 503, "Server busy, please retry", close, &["Retry-After: 1"])?; + return Ok(close); + } + + let font = match app.fonts.get_or_parse(&font_path) { + Ok(f) => f, + Err(cache::FontCacheError::NotFound) => { + misc::gate_release(est); + http::send_text(stream, 404, "font not found", close, &[])?; + return Ok(close); + } + Err(cache::FontCacheError::ParseFailed) => { + misc::gate_release(est); + http::send_text(stream, 422, "font parse failed", close, &[])?; + return Ok(close); + } + }; + let t2 = Instant::now(); + let result = match ttf::subset(&font, text) { + Ok(b) => b, + Err(ttf::SubsetError::NotTtf) => { + misc::gate_release(est); + http::send_text(stream, 422, "not a ttf font", close, &[])?; + return Ok(close); + } + Err(ttf::SubsetError::SubsetFailed) => { + misc::gate_release(est); + http::send_text(stream, 422, "subset failed", close, &[])?; + return Ok(close); + } + }; + // woff2 编码(outType=woff2 时)。Zig 版 `try` 上抛后 defer 释放闸门再静默收线 + let out_bytes: Vec = if out_woff2 { + match woff2::encode_ttf_to_woff2(&result) { + Ok(b) => b, + Err(_) => { + misc::gate_release(est); + return Ok(true); + } + } + } else { + result + }; + let t3 = Instant::now(); + misc::gate_release(est); + + app.subset_cache.insert(&cache_key, out_bytes.to_vec()); + + let timing = [ + format!("X-Timing-Find: {}", ms(t0, t1)), + format!("X-Timing-Read: {}", ms(t1, t2)), + format!("X-Timing-Subset: {}", ms(t2, t3)), + format!("X-Timing-Total: {}", ms(t0, t3)), + ]; + let timing: Vec<&str> = timing.iter().map(|s| s.as_str()).collect(); + let etag = http::etag_of(&out_bytes); + http::send_font( + stream, + &out_bytes, + close, + if out_woff2 { "font/woff2" } else { "font/ttf" }, + &["X-Cache: MISS"], + &timing, + &etag, + if_none_match, + )?; + Ok(close) +} + +/// 毫秒耗时(X-Timing-* 头) +fn ms(from: Instant, to: Instant) -> u128 { + to.duration_since(from).as_millis() +} + +/// 在所有字体目录中查找字体文件(对译 findFontPath:精确 > 前缀 > 包含,大小写不敏感,扩展名剥除比较) +pub(crate) fn find_font_path(dirs: &[String], name: &str) -> Option { + // 精确匹配 + for dir in dirs { + let p = format!("{dir}/{name}"); + if let Ok(md) = std::fs::metadata(&p) { + if md.is_file() { + return Some(p); + } + } + } + // 扫描目录收集(basename 剥扩展名 + 小写) + let mut all: Vec<(String, String)> = Vec::new(); // (stem 小写, path) + for dir in dirs { + let Ok(entries) = std::fs::read_dir(dir) else { continue }; + for entry in entries.flatten() { + // TS readdir 逐项 stat(跟随符号链接):必须用 std::fs::metadata(stat 语义), + // DirEntry::metadata 是 lstat——symlink 字体(如 /tmp/ssim-fonts 的基准链接)会被误跳过 + let Ok(md) = std::fs::metadata(entry.path()) else { continue }; + if !md.is_file() { + continue; + } + let fname = entry.file_name(); + let Some(fname) = fname.to_str() else { continue }; + if !has_font_ext(fname) { + continue; + } + all.push((strip_ext(fname).to_lowercase(), format!("{dir}/{fname}"))); + } + } + let query = strip_ext(name).to_lowercase(); + // 前缀匹配 + for (stem, path) in &all { + if stem.starts_with(&query) { + return Some(path.clone()); + } + } + // 包含匹配 + for (stem, path) in &all { + if stem.contains(&query) { + return Some(path.clone()); + } + } + None +} + +/// 剥最后一个扩展名(语义对齐 JS name.replace(/\.[^.]+$/, "")) +fn strip_ext(name: &str) -> &str { + match name.rfind('.') { + Some(dot) => &name[..dot], + None => name, + } +} + +/// 字体扩展名判定(大小写不敏感,语义对齐 /\.(ttf|otf|woff|woff2)$/i) +pub(crate) fn has_font_ext(name: &str) -> bool { + let lower = name.to_lowercase(); + [".ttf", ".otf", ".woff", ".woff2"].iter().any(|e| lower.len() > e.len() && lower.ends_with(e)) +} + +/// 纯计算微基准:parse 一次,循环 subset 计 avg/min,累积 checksum 防编译器死代码消除 +/// (对译 runBench;防 DCE 规则见 memory benchmark-dce-checksum-rule) +fn run_bench(args: &[String]) { + let (font_path, text, iters) = match args { + [f, t] => (f.as_str(), t.as_str(), 500usize), + [f, t, i] => (f.as_str(), t.as_str(), i.parse().unwrap_or(500)), + _ => { + eprintln!("用法: webfont-rs bench [iters]"); + std::process::exit(2); + } + }; + let data = std::fs::read(font_path).expect("read font"); + let t0 = Instant::now(); + let font = ttf::Font::parse(data).expect("parse"); + eprintln!("Font.parse: {}ms", t0.elapsed().as_millis()); + + let mut checksum: u64 = 0; + let mut total_us: u128 = 0; + let mut min_us: u128 = u128::MAX; + // 预热 20 次(页缓存/JIT 无但 allocator/缓存热身),计入 checksum + for _ in 0..20 { + let r = ttf::subset(&font, text).expect("subset"); + checksum = checksum.wrapping_add(r.len() as u64 + r[0] as u64 + r[r.len() - 1] as u64); + } + for _ in 0..iters { + let t0 = Instant::now(); + let r = ttf::subset(&font, text).expect("subset"); + let d = t0.elapsed(); + total_us += d.as_micros(); + min_us = min_us.min(d.as_micros()); + checksum = checksum.wrapping_add(r.len() as u64 + r[0] as u64 + r[r.len() - 1] as u64); + } + eprintln!( + "iters={iters} checksum=0x{checksum:x} avg={:.3}ms min={:.3}ms", + total_us as f64 / iters as f64 / 1000.0, + min_us as f64 / 1000.0, + ); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn extract_frame_partial_and_complete() { + let full = b"GET / HTTP/1.1\r\nHost: x\r\nContent-Length: 2\r\n\r\nhi"; + assert_eq!(extract_frame(full), Some(full.len())); + assert_eq!(extract_frame(&full[..full.len() - 1]), None); // body 未齐 + assert_eq!(extract_frame(b"GET / HTTP/1.1\r\n"), None); // 头未结束 + } + + #[test] + fn parse_request_fields() { + let req = b"GET /api?font=a.ttf&text=%E5%AD%97 HTTP/1.1\r\nConnection: close\r\n\r\nbody"; + let r = parse_request(req).unwrap(); + assert_eq!(r.method, "GET"); + assert_eq!(r.path, "/api"); + assert_eq!(r.query, "font=a.ttf&text=%E5%AD%97"); + assert_eq!(r.body, b"body"); + assert!(r.close); + } + + #[test] + fn font_ext_case_insensitive() { + assert!(has_font_ext("A.TTF")); + assert!(has_font_ext("x.woff2")); + assert!(!has_font_ext("x.ttf.txt")); + assert!(!has_font_ext(".ttf")); // 与 Zig 一致:len > e.len 才算 + } +} diff --git a/rust-spike/src/misc.rs b/rust-spike/src/misc.rs new file mode 100644 index 0000000..b08fd8a --- /dev/null +++ b/rust-spike/src/misc.rs @@ -0,0 +1,2595 @@ +//! 杂项路由与常驻设施(对译 zig-spike/src/misc.zig)—— 语义对齐 backend/ 的其余功能面: +//! - 路由:/api/fonts、/api/config、/api/stats、/api/stats/event、/api/upload、/api/font-meta +//! - 静态资源 + 字体详情页 SSR(backend/app.ts staticFileMiddleware + routes/font_detail.ts) +//! - 统计累计与 30s 防抖落盘(stats_store.ts)、临时字体清理器(temp_cleaner.ts) +//! - 内存闸门/并发排队 503(subset_queue.ts)、multipart 解析(multipart.ts)、上传(upload.ts) +//! - CORS 中间件语义:所有响应追加三个 Access-Control 头;OPTIONS 直接 204 不带 CORS +//! - glyph-match HTTP handler(原属 zig main.zig,Rust 侧归入本模块以收拢路由依赖) + +use std::collections::HashMap; +use std::io; +use std::net::TcpStream; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Mutex, OnceLock}; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use crate::cache::FontCache; +use crate::http; +use crate::glyph_match as gm; + +// ===== 配置(对齐 backend/config.ts,启动时从环境变量加载)===== + +/// 进程级配置(init 后只读) +pub struct Config { + /// 临时上传开关 + pub enable_temp_upload: bool, + /// 管理员 API Key,空则管理员上传不可用 + pub admin_api_key: String, + /// 临时上传目录最大文件数 + pub temp_max_files: usize, + /// 临时上传目录总体积上限(字节) + pub temp_max_total_size: usize, + /// 临时字体保留时限(秒) + pub temp_retention_seconds: u64, + /// 字体裁剪最大并发数 + pub subset_concurrency: usize, + /// 队列等待超时(秒) + pub subset_queue_timeout_seconds: u64, +} + +static CONFIG: OnceLock = OnceLock::new(); + +fn config() -> &'static Config { + CONFIG.get().expect("misc::init 未调用") +} + +/// 环境整数解析(非法回退默认值) +fn env_int(name: &str, default: i64) -> i64 { + std::env::var(name).ok().and_then(|s| s.parse::().ok()).unwrap_or(default) +} + +/// 环境正整数解析(<1 回退默认值) +fn env_usize(name: &str, default: usize) -> usize { + let v = env_int(name, default as i64); + if v < 1 { + default + } else { + v as usize + } +} + +// ===== 统计(对齐 backend/shared.ts stats + stats_store.ts)===== + +/// 持久化文件位置(与 TS 同一文件,切换运行时可无缝衔接) +const STATS_FILE: &str = "font/.stats.json"; +/// 落盘防抖间隔 +const STATS_FLUSH_MS: u64 = 30_000; + +#[derive(Clone, Copy, Default)] +struct Counters { + total_requests: u64, + subset_requests: u64, + subset_cache_hits: u64, + total_chars: u64, + temp_uploads: u64, + offline_subsets: u64, + offline_downloads: u64, +} + +struct StatsInner { + dirty: bool, + c: Counters, +} + +static STATS: Mutex = Mutex::new(StatsInner { + dirty: false, + c: Counters { + total_requests: 0, + subset_requests: 0, + subset_cache_hits: 0, + total_chars: 0, + temp_uploads: 0, + offline_subsets: 0, + offline_downloads: 0, + }, +}); +/// 启动时刻(uptime 只算本次进程) +static STATS_START_MS: OnceLock = OnceLock::new(); + +/// 墙钟毫秒(Date.now 等价) +pub fn wall_now_ms() -> i64 { + let now = SystemTime::now().duration_since(UNIX_EPOCH).expect("系统时钟早于 1970"); + now.as_millis() as i64 +} + +/// 初始化:解析配置、建目录、恢复统计、启动后台线程 +pub fn init() { + let cfg = Config { + enable_temp_upload: std::env::var("ENABLE_TEMP_UPLOAD").map(|v| v == "true").unwrap_or(false), + admin_api_key: std::env::var("ADMIN_API_KEY").unwrap_or_default(), + temp_max_files: env_usize("TEMP_MAX_FILES", 10), + temp_max_total_size: env_int("TEMP_MAX_TOTAL_SIZE", 200 * 1024 * 1024) as usize, + temp_retention_seconds: env_int("TEMP_RETENTION_SECONDS", 10800) as u64, + subset_concurrency: env_usize("SUBSET_CONCURRENCY", 4), + subset_queue_timeout_seconds: 5u64.max(env_int("SUBSET_QUEUE_TIMEOUT", 30) as u64), + }; + if CONFIG.set(cfg).is_err() { + panic!("misc::init 重复调用"); + } + + ensure_directories(); + load_stats(); + STATS_START_MS.set(wall_now_ms()).ok(); + + eprintln!("[config] temp upload: {}", config().enable_temp_upload); + eprintln!("[config] admin upload: {}", !config().admin_api_key.is_empty()); + + init_gate(); + + let _ = std::thread::Builder::new().name("stats-flush".into()).spawn(stats_flush_thread); + let _ = std::thread::Builder::new().name("temp-cleaner".into()).spawn(temp_cleaner_thread); +} + +fn ensure_directories() { + for dir in ["font/temp", "font/admin"] { + if std::fs::metadata(dir).is_err() { + let _ = std::fs::create_dir_all(dir); + } + } +} + +/// 从 font/.stats.json 恢复累计计数(缺失/损坏从 0 起步,对齐 loadPersistedStats) +fn load_stats() { + let Ok(raw) = std::fs::read_to_string(STATS_FILE) else { return }; + let Some(v) = json_parse(raw.trim()) else { return }; + let mut g = STATS.lock().unwrap(); + g.c.total_requests = json_u64(&v, "totalRequests", g.c.total_requests); + g.c.subset_requests = json_u64(&v, "subsetRequests", g.c.subset_requests); + g.c.subset_cache_hits = json_u64(&v, "subsetCacheHits", g.c.subset_cache_hits); + g.c.total_chars = json_u64(&v, "totalChars", g.c.total_chars); + g.c.temp_uploads = json_u64(&v, "tempUploads", g.c.temp_uploads); + g.c.offline_subsets = json_u64(&v, "offlineSubsets", g.c.offline_subsets); + g.c.offline_downloads = json_u64(&v, "offlineDownloads", g.c.offline_downloads); +} + +/// 对象字段取无符号整数(缺失/类型不符回退默认) +fn json_u64(v: &JsonValue, key: &str, default: u64) -> u64 { + let Some(f) = obj_get(v, key) else { return default }; + match f { + JsonValue::Num(n) if *n >= 0.0 && n.fract() == 0.0 => *n as u64, + _ => default, + } +} + +/// 每请求计数 + 标脏(对齐 logMiddleware + markStatsDirty) +pub fn stats_total_request() { + let mut g = STATS.lock().unwrap(); + g.c.total_requests += 1; + g.dirty = true; +} + +/// 子集化计数:请求次数 + 累计字符数(UTF-16 码元口径,对齐 text.length) +pub fn stats_record_subset(utf16_units: usize) { + let mut g = STATS.lock().unwrap(); + g.c.subset_requests += 1; + g.c.total_chars += utf16_units as u64; + g.dirty = true; +} + +pub fn stats_record_cache_hit() { + let mut g = STATS.lock().unwrap(); + g.c.subset_cache_hits += 1; + g.dirty = true; +} + +pub fn stats_record_temp_upload() { + let mut g = STATS.lock().unwrap(); + g.c.temp_uploads += 1; + g.dirty = true; +} + +pub fn stats_record_offline(subset: bool) { + let mut g = STATS.lock().unwrap(); + if subset { + g.c.offline_subsets += 1; + } else { + g.c.offline_downloads += 1; + } + g.dirty = true; +} + +fn stats_flush_thread() { + loop { + std::thread::sleep(Duration::from_millis(STATS_FLUSH_MS)); + let snap = { + let mut g = STATS.lock().unwrap(); + if !g.dirty { + continue; + } + g.dirty = false; + g.c + }; + let json = stats_json(snap); + if std::fs::write(STATS_FILE, json).is_err() { + // 写盘失败把脏标放回,等下个周期重试(对齐 flushStats 失败路径) + let mut g = STATS.lock().unwrap(); + g.dirty = true; + } + } +} + +fn stats_json(c: Counters) -> String { + format!( + "{{\"totalRequests\":{},\"subsetRequests\":{},\"subsetCacheHits\":{},\"totalChars\":{},\"tempUploads\":{},\"offlineSubsets\":{},\"offlineDownloads\":{}}}", + c.total_requests, c.subset_requests, c.subset_cache_hits, c.total_chars, c.temp_uploads, c.offline_subsets, c.offline_downloads + ) +} + +// ===== 临时字体清理器(对齐 backend/temp_cleaner.ts)===== + +/// 字体最后使用时间戳(key = 文件名) +static LAST_USED: Mutex>> = Mutex::new(None); + +/// 闭包访问 last_used 表(惰性初始化;静态上下文不能调 HashMap::new) +fn with_last_used(f: impl FnOnce(&mut HashMap) -> R) -> R { + let mut g = LAST_USED.lock().unwrap(); + f(g.get_or_insert_with(HashMap::new)) +} + +/// 记录临时字体被使用(仅 font/temp 下文件,对齐 markFontUsed) +pub fn mark_font_used(font_path: &str) { + if !font_path.starts_with("font/temp/") { + return; + } + let name = match font_path.rfind('/') { + Some(i) => &font_path[i + 1..], + None => font_path, + }; + let now = wall_now_ms(); + with_last_used(|m| m.insert(name.to_string(), now)); +} + +fn clean_once() { + let now = wall_now_ms(); + let retention_ms = config().temp_retention_seconds * 1000; + let Ok(entries) = std::fs::read_dir("font/temp") else { return }; + let mut names: Vec = Vec::new(); + for entry in entries.flatten() { + // 只删普通文件(对齐 entry.kind != .file 跳过) + let Ok(ft) = entry.file_type() else { continue }; + if !ft.is_file() { + continue; + } + let fname = entry.file_name(); + let Some(fname) = fname.to_str() else { continue }; + if !crate::has_font_ext(fname) { + continue; + } + names.push(fname.to_string()); + } + let mut cleaned: usize = 0; + for name in names { + let Ok(md) = std::fs::metadata(format!("font/temp/{name}")) else { continue }; + let last_used_ms = with_last_used(|m| m.get(&name).copied().unwrap_or(0)); + let mtime_ms = md + .modified() + .ok() + .and_then(|t| t.duration_since(UNIX_EPOCH).ok()) + .map(|d| d.as_millis() as i64) + .unwrap_or(0); + let last_active = last_used_ms.max(mtime_ms); + if now - last_active > retention_ms as i64 { + if std::fs::remove_file(format!("font/temp/{name}")).is_err() { + continue; + } + with_last_used(|m| m.remove(&name)); + cleaned += 1; + } + } + if cleaned > 0 { + eprintln!("[temp-cleaner] 本次清理 {cleaned} 个过期临时字体"); + } +} + +fn temp_cleaner_thread() { + // 清理周期 = 保留时限的一半,最少 5 分钟 + let clean_interval_ms: u64 = (config().temp_retention_seconds * 500).max(300_000); + eprintln!( + "[temp-cleaner] 启动,保留时限 {}s,清理周期 {}s", + config().temp_retention_seconds, + clean_interval_ms / 1000 + ); + std::thread::sleep(Duration::from_secs(60)); + loop { + clean_once(); + std::thread::sleep(Duration::from_millis(clean_interval_ms)); + } +} + +// ===== 内存闸门(对齐 backend/subset_queue.ts)===== + +struct GateInner { + active: usize, + #[allow(dead_code)] // waiting 只作排队计数,语义保留 + waiting: usize, + reserved: usize, +} + +static GATE: Mutex = Mutex::new(GateInner { active: 0, waiting: 0, reserved: 0 }); +/// init_gate 已执行的标记(打印一次启动行) +static GATE_INITED: AtomicBool = AtomicBool::new(false); + +const MIB: usize = 1024 * 1024; + +/// 内存快照:宿主/容器空闲与保留水位 +struct MemSnap { + limit: u64, + free: u64, + reserve: u64, +} + +/// 读 cgroup/proc 数值文件("max"/非法 → None) +fn read_memory_file(path: &str) -> Option { + let raw = std::fs::read_to_string(path).ok()?; + let s = raw.trim_matches(|c: char| c == ' ' || c == '\t' || c == '\r' || c == '\n'); + if s == "max" { + return None; + } + s.parse::().ok() +} + +/// cgroup v2 优先,再 v1(对齐 readCgroupMemory) +fn read_cgroup_memory() -> Option<(u64, u64)> { + if let Some(limit) = read_memory_file("/sys/fs/cgroup/memory.max") { + if let Some(used) = read_memory_file("/sys/fs/cgroup/memory.current") { + if limit > 0 { + return Some((limit, limit.saturating_sub(used))); + } + } + } + if let Some(limit) = read_memory_file("/sys/fs/cgroup/memory/memory.limit_in_bytes") { + if let Some(used) = read_memory_file("/sys/fs/cgroup/memory/memory.usage_in_bytes") { + if limit > 0 { + return Some((limit, limit.saturating_sub(used))); + } + } + } + None +} + +/// /proc/meminfo 兜底(os.totalmem/freemem 等价物) +fn read_meminfo() -> Option<(u64, u64)> { + let raw = std::fs::read_to_string("/proc/meminfo").ok()?; + let mut total: u64 = 0; + let mut available: u64 = 0; + for line in raw.split('\n') { + let Some(colon) = line.find(':') else { continue }; + let key = &line[..colon]; + let mut val = line[colon + 1..].trim_matches(|c: char| c == ' ' || c == '\t'); + if let Some(stripped) = val.strip_suffix(" kB") { + val = stripped; + } + let Ok(n) = val.trim().parse::() else { continue }; + if key == "MemTotal" { + total = n * 1024; + } + if key == "MemAvailable" { + available = n * 1024; + } + } + if total == 0 { + return None; + } + Some((total, available)) +} + +/// 每次准入都读取当前水位,不缓存(对齐 readMemorySnapshot) +fn read_memory_snapshot() -> MemSnap { + let (limit, free) = match read_cgroup_memory() { + Some(c) => c, + None => match read_meminfo() { + Some(m) => m, + None => (2 * 1024 * MIB as u64, 1024 * MIB as u64), + }, + }; + // 给运行时和静态请求保留内存,绝不把水位用满 + let reserve = (32 * MIB as u64).max((128 * MIB as u64).min(limit / 10)); + MemSnap { limit, free, reserve } +} + +/// 小内存机器最多同时执行两个重任务(对齐 concurrencyLimit) +fn concurrency_limit(limit: u64) -> usize { + let max_conc = config().subset_concurrency.max(1); + if limit <= 2 * 1024 * MIB as u64 { + max_conc.min(2) + } else { + max_conc + } +} + +pub fn init_gate() { + if !GATE_INITED.swap(true, Ordering::SeqCst) { + eprintln!("[subset-queue] maxConcurrency={}, memoryAware=true", config().subset_concurrency.max(1)); + } +} + +/// 排队获取闸门槽位;超时返回 false(调用方回 503)。对齐 withMemoryGate 的轮询语义。 +pub fn gate_acquire(timeout_ms: i64, estimated: usize) -> bool { + let t0 = Instant::now(); + let mut queued = false; + loop { + let memory = read_memory_snapshot(); + let granted = { + let mut g = GATE.lock().unwrap(); + let has_slot = g.active < concurrency_limit(memory.limit); + let available = memory + .free + .saturating_sub(memory.reserve) + .saturating_sub(g.reserved as u64); + // 没有任务运行时允许启动一个大任务,避免预估值偏大造成永久饥饿 + let has_memory = if g.active == 0 { available > 0 } else { available >= estimated as u64 }; + if has_slot && has_memory { + if queued { + g.waiting -= 1; + } + g.active += 1; + g.reserved += estimated; + true + } else { + if !queued { + queued = true; + g.waiting += 1; + } + false + } + }; + if granted { + return true; + } + + let elapsed = t0.elapsed().as_millis() as i64; + if elapsed >= timeout_ms { + let mut g = GATE.lock().unwrap(); + g.waiting -= 1; + return false; + } + let remain = (timeout_ms - elapsed) as u64; + std::thread::sleep(Duration::from_millis(remain.min(50))); + } +} + +pub fn gate_release(estimated: usize) { + let mut g = GATE.lock().unwrap(); + g.active -= 1; + g.reserved -= estimated; +} + +/// 源文件内存预估:max(64MB, size*4)(对齐 estimateSubsetMemory) +pub fn estimate_subset_memory(font_path: &str) -> usize { + match std::fs::metadata(font_path) { + Ok(md) => (md.len() as usize * 4).max(64 * MIB), + Err(_) => 64 * MIB, + } +} + +/// 队列超时毫秒 +pub fn queue_timeout_ms() -> i64 { + (config().subset_queue_timeout_seconds * 1000) as i64 +} + +// ===== 通用 JSON 辅助 ===== + +/// 写 JSON 字符串字面量(转义规则对齐 JSON.stringify:仅转义必要字符,UTF-8 原样输出) +pub fn json_stringify_str(s: &str) -> String { + let mut out = String::with_capacity(s.len() + 2); + out.push('"'); + for c in s.chars() { + match c { + '"' => out.push_str("\\\""), + '\\' => out.push_str("\\\\"), + '\n' => out.push_str("\\n"), + '\r' => out.push_str("\\r"), + '\t' => out.push_str("\\t"), + '\u{0008}' => out.push_str("\\b"), + '\u{000c}' => out.push_str("\\f"), + c if (c as u32) < 0x20 => out.push_str(&format!("\\u00{:02x}", c as u32)), + c => out.push(c), + } + } + out.push('"'); + out +} + +/// f64 格式化对齐 JS number:整数值不带小数点,小数保留一位(覆盖率百分比的取值域) +fn json_percent(p: f64) -> String { + if p == p.trunc() { + format!("{}", p as i64) + } else { + format!("{p:.1}") + } +} + +/// text.length UTF-16 码元口径(对齐 utf16LenUtf8:非法序列按 1 计) +pub fn utf16_len_utf8(s: &str) -> usize { + let b = s.as_bytes(); + let mut n: usize = 0; + let mut i: usize = 0; + while i < b.len() { + let len = match utf8_seq_len(b[i]) { + Some(l) => l, + None => { + i += 1; + n += 1; + continue; + } + }; + if i + len > b.len() { + i += 1; + n += 1; + continue; + } + match std::str::from_utf8(&b[i..i + len]) { + Ok(t) => { + // from_utf8 校验通过后 chars() 恰为 1 个标量值 + n += if t.chars().next().unwrap() as u32 > 0xFFFF { 2 } else { 1 }; + } + Err(_) => { + i += 1; + n += 1; + continue; + } + } + i += len; + } + n +} + +/// UTF-8 首字节 → 序列长度(非法返回 None) +fn utf8_seq_len(first: u8) -> Option { + match first { + 0x00..=0x7f => Some(1), + 0xc0..=0xdf => Some(2), + 0xe0..=0xef => Some(3), + 0xf0..=0xf7 => Some(4), + _ => None, + } +} + +// ===== 极简 JSON 解析器(对齐 std.json.parseFromSliceLeaky 的取值需求子集)===== + +/// JSON 值(解析失败的条目返回 None;对象保序线性查找) +#[derive(Debug, Clone, PartialEq)] +pub enum JsonValue { + Null, + Bool(bool), + Num(f64), + Str(String), + Arr(Vec), + Obj(Vec<(String, JsonValue)>), +} + +impl JsonValue { + /// 对象取字段 + pub fn get(&self, key: &str) -> Option<&JsonValue> { + match self { + JsonValue::Obj(items) => items.iter().find(|(k, _)| k == key).map(|(_, v)| v), + _ => None, + } + } + /// 取字符串字段(存在但类型不符返回 None——上层转 400,对齐 Zig 类型化解析) + pub fn get_str(&self, key: &str) -> Option> { + match self.get(key) { + Some(JsonValue::Str(s)) => Some(Some(s.as_str())), + Some(_) => None, + None => Some(None), + } + } + /// 取整数(integer/float 均接受,越界/负数/非数返回 None) + pub fn get_u32(&self, key: &str) -> Option> { + match self.get(key) { + Some(JsonValue::Num(n)) if *n >= 0.0 && *n <= u32::MAX as f64 && n.fract() == 0.0 => { + Some(Some(*n as u32)) + } + Some(_) => None, + None => Some(None), + } + } +} + +/// 解析 JSON 文本(语法错误返回 None;递归深度限 256 对齐 std.json 默认) +pub fn json_parse(s: &str) -> Option { + let b = s.as_bytes(); + let mut p = Parser { b, i: 0 }; + p.skip_ws(); + let v = p.value(0)?; + p.skip_ws(); + if p.i != b.len() { + return None; + } + Some(v) +} + +struct Parser<'a> { + b: &'a [u8], + i: usize, +} + +const MAX_DEPTH: usize = 256; + +impl Parser<'_> { + fn skip_ws(&mut self) { + while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\t' | b'\n' | b'\r') { + self.i += 1; + } + } + + fn peek(&self) -> Option { + self.b.get(self.i).copied() + } + + fn value(&mut self, depth: usize) -> Option { + if depth > MAX_DEPTH { + return None; + } + self.skip_ws(); + match self.peek()? { + b'{' => self.object(depth), + b'[' => self.array(depth), + b'"' => self.string().map(JsonValue::Str), + b't' => self.lit(b"true", JsonValue::Bool(true)), + b'f' => self.lit(b"false", JsonValue::Bool(false)), + b'n' => self.lit(b"null", JsonValue::Null), + _ => self.number(), + } + } + + fn lit(&mut self, word: &[u8], v: JsonValue) -> Option { + if self.b.len() - self.i >= word.len() && &self.b[self.i..self.i + word.len()] == word { + self.i += word.len(); + Some(v) + } else { + None + } + } + + fn object(&mut self, depth: usize) -> Option { + self.i += 1; // '{' + let mut items: Vec<(String, JsonValue)> = Vec::new(); + self.skip_ws(); + if self.peek()? == b'}' { + self.i += 1; + return Some(JsonValue::Obj(items)); + } + loop { + self.skip_ws(); + let key = self.string()?; + self.skip_ws(); + if self.peek()? != b':' { + return None; + } + self.i += 1; + let v = self.value(depth + 1)?; + items.push((key, v)); + self.skip_ws(); + match self.peek()? { + b',' => self.i += 1, + b'}' => { + self.i += 1; + return Some(JsonValue::Obj(items)); + } + _ => return None, + } + } + } + + fn array(&mut self, depth: usize) -> Option { + self.i += 1; // '[' + let mut items: Vec = Vec::new(); + self.skip_ws(); + if self.peek()? == b']' { + self.i += 1; + return Some(JsonValue::Arr(items)); + } + loop { + let v = self.value(depth + 1)?; + items.push(v); + self.skip_ws(); + match self.peek()? { + b',' => self.i += 1, + b']' => { + self.i += 1; + return Some(JsonValue::Arr(items)); + } + _ => return None, + } + } + } + + fn string(&mut self) -> Option { + if self.peek()? != b'"' { + return None; + } + self.i += 1; + // 统一字节缓冲:转义与原始字节都 append,最后整体验 UTF-8 + //(非法 UTF-8 → 解析失败,对齐 std.json 严格校验) + let mut bytes: Vec = Vec::new(); + loop { + let c = self.peek()?; + self.i += 1; + match c { + b'"' => return String::from_utf8(bytes).ok(), + b'\\' => { + let e = self.peek()?; + self.i += 1; + match e { + b'"' => bytes.push(b'"'), + b'\\' => bytes.push(b'\\'), + b'/' => bytes.push(b'/'), + b'b' => bytes.push(0x08), + b'f' => bytes.push(0x0c), + b'n' => bytes.push(b'\n'), + b'r' => bytes.push(b'\r'), + b't' => bytes.push(b'\t'), + b'u' => { + // \uXXXX(代理对合成,对齐 JSON 标准;孤立代理解析失败,对齐 std.json) + let hi = self.hex4()?; + let cp = if (0xd800..=0xdbff).contains(&hi) { + // 高代理必须紧跟 \uDC00-\uDFFF + if self.b.len() - self.i >= 6 + && self.b[self.i] == b'\\' + && self.b[self.i + 1] == b'u' + { + self.i += 2; + let lo = self.hex4()?; + if (0xdc00..=0xdfff).contains(&lo) { + 0x10000 + ((hi - 0xd800) << 10) + (lo - 0xdc00) + } else { + return None; + } + } else { + return None; + } + } else if (0xdc00..=0xdfff).contains(&hi) { + return None; + } else { + hi + }; + let ch = char::from_u32(cp)?; + let mut buf = [0u8; 4]; + bytes.extend_from_slice(ch.encode_utf8(&mut buf).as_bytes()); + } + _ => return None, + } + } + 0x00..=0x1f => return None, + _ => bytes.push(c), + } + } + } + + fn hex4(&mut self) -> Option { + if self.b.len() - self.i < 4 { + return None; + } + let mut v: u32 = 0; + for k in 0..4 { + let d = (self.b[self.i + k] as char).to_digit(16)?; + v = v * 16 + d; + } + self.i += 4; + Some(v) + } + + fn number(&mut self) -> Option { + let start = self.i; + if self.peek() == Some(b'-') { + self.i += 1; + } + let mut any = false; + while let Some(c) = self.peek() { + if c.is_ascii_digit() || c == b'.' || c == b'e' || c == b'E' || c == b'+' || c == b'-' { + self.i += 1; + any = true; + } else { + break; + } + } + if !any { + return None; + } + std::str::from_utf8(&self.b[start..self.i]).ok()?.parse::().ok().map(JsonValue::Num) + } +} + +/// 对象取字段(json_parse 结果的便捷入口) +fn obj_get<'a>(v: &'a JsonValue, key: &str) -> Option<&'a JsonValue> { + v.get(key) +} + +// ===== GET /api/fonts(对齐 backend/routes/fonts.ts)===== + +/// 目录条目判定是否为普通文件(symlink 需跟进一次 metadata,对齐 readdir+statFile 语义) +fn entry_is_file(entry: &std::fs::DirEntry, dir: &str) -> bool { + let Ok(ft) = entry.file_type() else { return false }; + if ft.is_file() { + return true; + } + if ft.is_symlink() { + let fname = entry.file_name(); + let Some(fname) = fname.to_str() else { return false }; + return std::fs::metadata(format!("{dir}/{fname}")).map(|m| m.is_file()).unwrap_or(false); + } + false +} + +pub fn handle_list_fonts( + stream: &mut TcpStream, + dirs: &[String], + close: bool, +) -> io::Result { + let mut body = String::from("["); + let mut first = true; + for dir in dirs { + let Ok(entries) = std::fs::read_dir(dir) else { continue }; + for entry in entries.flatten() { + if !entry_is_file(&entry, dir) { + continue; + } + let fname = entry.file_name(); + let Some(fname) = fname.to_str() else { continue }; + if !crate::has_font_ext(fname) { + continue; + } + if !first { + body.push(','); + } + first = false; + body.push_str("{\"name\":"); + body.push_str(&json_stringify_str(fname)); + body.push_str(&format!(",\"temporary\":{}}}", *dir == *"font/temp")); + } + } + body.push(']'); + http::send_json(stream, 200, &body, close)?; + Ok(close) +} + +// ===== GET /api/config(对齐 backend/routes/config.ts)===== + +pub fn handle_get_config(stream: &mut TcpStream, close: bool) -> io::Result { + let c = config(); + let body = format!( + "{{\"enableTempUpload\":{},\"adminUploadEnabled\":{},\"supportedOutTypes\":[\"ttf\",\"woff2\"],\"tempRetentionSeconds\":{},\"subsetConcurrency\":{},\"subsetQueueTimeoutSeconds\":{}}}", + c.enable_temp_upload, + !c.admin_api_key.is_empty(), + c.temp_retention_seconds, + c.subset_concurrency, + c.subset_queue_timeout_seconds, + ); + http::send_json(stream, 200, &body, close)?; + Ok(close) +} + +// ===== GET /api/stats + POST /api/stats/event(对齐 backend/routes/stats.ts)===== + +pub fn handle_stats( + stream: &mut TcpStream, + close: bool, + subset_cache_entries: usize, + font_buffer_cache_entries: usize, +) -> io::Result { + let c = { STATS.lock().unwrap().c }; + let uptime: u64 = (wall_now_ms() - STATS_START_MS.get().copied().unwrap_or(0)).max(0) as u64 / 1000; + let body = format!( + "{{\"uptime\":{},\"totalRequests\":{},\"subsetRequests\":{},\"subsetCacheHits\":{},\"totalChars\":{},\"tempUploads\":{},\"offlineSubsets\":{},\"offlineDownloads\":{},\"subsetCacheEntries\":{},\"fontBufferCacheEntries\":{}}}", + uptime, c.total_requests, c.subset_requests, c.subset_cache_hits, c.total_chars, + c.temp_uploads, c.offline_subsets, c.offline_downloads, + subset_cache_entries, font_buffer_cache_entries, + ); + http::send_json(stream, 200, &body, close)?; + Ok(close) +} + +pub fn handle_stats_event(stream: &mut TcpStream, body: &[u8], close: bool) -> io::Result { + if body.is_empty() { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"请求体为空\"}", close)?; + return Ok(close); + } + let Ok(text) = std::str::from_utf8(body) else { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"invalid body\"}", close)?; + return Ok(close); + }; + let Some(parsed) = json_parse(text) else { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"invalid body\"}", close)?; + return Ok(close); + }; + // event 字段(缺失 → unknown event;类型不符 → invalid body,对齐 Zig 类型化解析) + let Some(ev) = parsed.get_str("event") else { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"invalid body\"}", close)?; + return Ok(close); + }; + let Some(ev) = ev else { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"unknown event\"}", close)?; + return Ok(close); + }; + // 白名单校验(对齐 OFFLINE_EVENTS),只累计计数不记录内容 + match ev { + "offline_subset" => stats_record_offline(true), + "offline_download" => stats_record_offline(false), + _ => { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"unknown event\"}", close)?; + return Ok(close); + } + } + http::send_json(stream, 200, "{\"success\":true}", close)?; + Ok(close) +} + +// ===== multipart 解析(对齐 backend/multipart.ts)===== + +/// multipart 单文件条目 +struct MultipartFile<'a> { + /// 表单字段名 + #[allow(dead_code)] // 只消费第一个 part 的数据,name 字段语义保留 + name: &'a [u8], + /// 原始文件名(原始字节,取用时 lossy 转 str) + filename: &'a [u8], + /// 文件二进制数据 + data: &'a [u8], +} + +/// 解析 multipart body(缺 boundary/起始边界返回 None → 上层 400) +fn parse_multipart<'a>(content_type: &str, body: &'a [u8]) -> Option>> { + let bo = content_type.find("boundary=")?; + let mut boundary = &content_type[bo + "boundary=".len()..]; + if let Some(i) = boundary.find(';') { + boundary = &boundary[..i]; + } + if let Some(i) = boundary.find(' ') { + boundary = &boundary[..i]; + } + // 对齐 boundaryMatch[1].replace(/^"(.*)"$/, "$1") + if boundary.len() >= 2 && boundary.starts_with('"') && boundary.ends_with('"') { + boundary = &boundary[1..boundary.len() - 1]; + } + + let mut files: Vec = Vec::new(); + let delimiter = format!("\r\n--{boundary}"); + let start_boundary = format!("--{boundary}\r\n"); + + let sb_pos = find_bytes(body, start_boundary.as_bytes())?; + let mut pos = sb_pos + start_boundary.len(); + + while pos < body.len() { + let Some(header_end) = find_bytes_from(body, pos, b"\r\n\r\n") else { break }; + let header_text = &body[pos..header_end]; + let body_start = header_end + 4; + + let Some(next_boundary) = find_bytes_from(body, body_start, delimiter.as_bytes()) else { break }; + + // part body 去掉末尾 "\r\n" + let mut part = &body[body_start..next_boundary]; + if part.len() >= 2 && part[part.len() - 1] == 10 && part[part.len() - 2] == 13 { + part = &part[..part.len() - 2]; + } + + // 从 Content-Disposition 解析 name/filename(对齐 name="([^"]*)";原始字节,不做 UTF-8 校验) + let name = match_quoted_attr(header_text, b"name="); + let filename = match_quoted_attr(header_text, b"filename="); + if let Some(n) = name { + files.push(MultipartFile { + name: n, + filename: filename.unwrap_or(&[]), + data: part, + }); + } + + pos = next_boundary + delimiter.len(); + // boundary 后紧跟 "--" 表示结束 + if pos + 2 <= body.len() && body[pos] == 45 && body[pos + 1] == 45 { + break; + } + // 跳过 boundary 后的 "\r\n" + if pos + 1 < body.len() && body[pos] == 13 && body[pos + 1] == 10 { + pos += 2; + } + } + Some(files) +} + +/// 子串查找(全 haystack) +fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option { + find_bytes_from(haystack, 0, needle) +} + +/// 子串查找(从 from 起) +fn find_bytes_from(haystack: &[u8], from: usize, needle: &[u8]) -> Option { + if needle.is_empty() || haystack.len() < needle.len() { + return None; + } + (from..=haystack.len() - needle.len()).find(|&i| &haystack[i..i + needle.len()] == needle) +} + +/// 从 header 文本中取 attr="value" 的 value(正则 /attr="([^"]*)"/ 的字面实现) +fn match_quoted_attr<'a>(header: &'a [u8], attr: &[u8]) -> Option<&'a [u8]> { + let mut search_from: usize = 0; + while let Some(start) = find_bytes_from(header, search_from, attr) { + // 属性名前必须是字段分界(行首/空白/分号),防止 filename= 匹配到 xxxfilename= + if start == 0 || header[start - 1] == b' ' || header[start - 1] == b';' || header[start - 1] == b'\n' { + let rest = &header[start + attr.len()..]; + if rest.len() >= 2 && rest[0] == b'"' { + if let Some(end) = rest[1..].iter().position(|&b| b == b'"') { + return Some(&rest[1..1 + end]); + } + } + return None; + } + search_from = start + attr.len(); + } + None +} + +// ===== POST /api/upload(对齐 backend/routes/upload.ts + upload.ts)===== + +const MAX_UPLOAD_SIZE: usize = 50 * 1024 * 1024; + +/// 允许的字体扩展名(对齐 isAllowedFontFile) +fn is_allowed_font_file(filename: &str) -> bool { + crate::has_font_ext(filename) +} + +/// 清理文件名:移除路径分隔符/控制字符/路径穿越/隐藏前缀(对齐 sanitizeFilename) +fn sanitize_filename(filename: &str) -> String { + let mut out = String::new(); + for c in filename.chars() { + if c == '/' || c == '\\' || c < ' ' { + continue; + } + out.push(c); + } + // 移除所有 ".." + let mut no_dots = String::new(); + let chars: Vec = out.chars().collect(); + let mut i = 0; + while i < chars.len() { + if i + 1 < chars.len() && chars[i] == '.' && chars[i + 1] == '.' { + i += 2; + continue; + } + no_dots.push(chars[i]); + i += 1; + } + // 去掉开头的 '.' + if no_dots.starts_with('.') { + return no_dots; + } + if no_dots.is_empty() { + return "unnamed.ttf".to_string(); + } + no_dots +} + +fn ensure_dir(dir: &str) { + if std::fs::metadata(dir).is_err() { + let _ = std::fs::create_dir_all(dir); + } +} + +/// 上传处理结果 +struct UploadResult { + success: bool, + err: Option<&'static str>, +} + +fn write_upload_result(r: &UploadResult) -> String { + if r.success { + "{\"success\":true}".to_string() + } else { + format!( + "{{\"success\":false,\"error\":{}}}", + json_stringify_str(r.err.unwrap_or("")) + ) + } +} + +/// temp 目录字体文件条目 +struct TempFile { + name: String, + size: u64, +} + +/// temp 目录字体文件清单(name+size,readdir 顺序近似 FIFO,对齐 getTempFontFiles) +fn get_temp_font_files() -> Vec { + let Ok(entries) = std::fs::read_dir("font/temp") else { return Vec::new() }; + let mut files: Vec = Vec::new(); + for entry in entries.flatten() { + let Ok(ft) = entry.file_type() else { continue }; + if !ft.is_file() { + continue; + } + let fname = entry.file_name(); + let Some(fname) = fname.to_str() else { continue }; + if !is_allowed_font_file(fname) { + continue; + } + let Ok(md) = entry.metadata() else { continue }; + files.push(TempFile { name: fname.to_string(), size: md.len() }); + } + files +} + +/// 按需清理 temp 目录使数量/体积满足限制(对齐 evictIfNeeded;incoming 为净新增字节) +fn evict_if_needed(incoming: i64) { + let files = get_temp_font_files(); + let c = config(); + let dir = "font/temp"; + + // 数量超限时按 readdir 顺序删最早的 + let mut kept: Vec = files; + while kept.len() >= c.temp_max_files { + let oldest = kept.remove(0); + let _ = std::fs::remove_file(format!("{dir}/{}", oldest.name)); + } + + let total: u64 = kept.iter().map(|f| f.size).sum(); + let needed = total as i64 + incoming - c.temp_max_total_size as i64; + if needed > 0 { + let mut freed: i64 = 0; + for f in &kept { + if freed >= needed { + break; + } + let _ = std::fs::remove_file(format!("{dir}/{}", f.name)); + freed += f.size as i64; + } + } +} + +fn handle_temp_upload(data: &[u8], filename: &str) -> UploadResult { + if !config().enable_temp_upload { + return UploadResult { success: false, err: Some("临时上传功能未启用") }; + } + if !is_allowed_font_file(filename) { + return UploadResult { success: false, err: Some("不支持的字体文件格式,仅支持 ttf/otf/woff/woff2") }; + } + ensure_dir("font/temp"); + let name = sanitize_filename(filename); + let path = format!("font/temp/{name}"); + // 同名覆盖不算新增,但新文件可能更大仍需检查总体积 + match std::fs::metadata(&path) { + Ok(existing) => evict_if_needed(data.len() as i64 - existing.len() as i64), + Err(_) => evict_if_needed(data.len() as i64), + } + if std::fs::write(&path, data).is_err() { + return UploadResult { success: false, err: Some("写入失败") }; + } + UploadResult { success: true, err: None } +} + +fn handle_admin_upload(data: &[u8], filename: &str, api_key: &str) -> UploadResult { + if config().admin_api_key.is_empty() { + return UploadResult { success: false, err: Some("管理员上传功能未启用") }; + } + if api_key != config().admin_api_key { + return UploadResult { success: false, err: Some("API Key 无效") }; + } + if !is_allowed_font_file(filename) { + return UploadResult { success: false, err: Some("不支持的字体文件格式,仅支持 ttf/otf/woff/woff2") }; + } + ensure_dir("font/admin"); + let name = sanitize_filename(filename); + let path = format!("font/admin/{name}"); + if std::fs::write(&path, data).is_err() { + return UploadResult { success: false, err: Some("写入失败") }; + } + UploadResult { success: true, err: None } +} + +/// 从请求原始字节取头值(大小写不敏感) +pub fn get_header<'a>(req: &'a [u8], name: &str) -> Option<&'a str> { + let mut it = req.split(|&b| b == b'\n'); + let _ = it.next(); // request line + for h in it { + let h = if h.last() == Some(&b'\r') { &h[..h.len() - 1] } else { h }; + if h.is_empty() { + break; + } + let Some(colon) = h.iter().position(|&b| b == b':') else { continue }; + let key = &h[..colon]; + if !key.eq_ignore_ascii_case(name.as_bytes()) { + continue; + } + let v = &h[colon + 1..]; + let Ok(v) = std::str::from_utf8(v) else { continue }; + return Some(v.trim_matches(|c: char| c == ' ' || c == '\t')); + } + None +} + +pub fn handle_upload( + stream: &mut TcpStream, + raw_req: &[u8], + query: &str, + body: &[u8], + close: bool, +) -> io::Result { + // mode 参数(默认 temp) + let mut mode: Option = None; + for kv in query.split('&') { + let Some(eq) = kv.find('=') else { continue }; + if &kv[..eq] == "mode" { + mode = String::from_utf8(http::url_decode(&kv[eq + 1..])).ok(); + } + } + + let content_type = get_header(raw_req, "Content-Type").unwrap_or(""); + + // 上传大小限制(对齐 uploadSizeMiddleware) + let content_length: i64 = get_header(raw_req, "Content-Length") + .and_then(|cl| cl.parse::().ok()) + .unwrap_or(0); + if content_length > MAX_UPLOAD_SIZE as i64 { + let body = write_upload_result(&UploadResult { success: false, err: Some("文件过大,最大 50MB") }); + http::send_json(stream, 413, &body, close)?; + return Ok(close); + } + + if body.is_empty() { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"请求体为空\"}", close)?; + return Ok(close); + } + + let Some(files) = parse_multipart(content_type, body) else { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"无效的 multipart 数据\"}", close)?; + return Ok(close); + }; + if files.is_empty() { + http::send_json(stream, 400, "{\"success\":false,\"error\":\"未提供文件\"}", close)?; + return Ok(close); + } + let file = &files[0]; + let filename = String::from_utf8_lossy(file.filename).into_owned(); + + if mode.as_deref() == Some("admin") { + let auth = get_header(raw_req, "Authorization").unwrap_or(""); + let api_key = auth.strip_prefix("Bearer ").unwrap_or(auth); + let result = handle_admin_upload(file.data, &filename, api_key); + let out = write_upload_result(&result); + http::send_json(stream, if result.success { 200 } else { 403 }, &out, close)?; + return Ok(close); + } + + let result = handle_temp_upload(file.data, &filename); + if result.success { + stats_record_temp_upload(); + } + let out = write_upload_result(&result); + http::send_json(stream, if result.success { 200 } else { 400 }, &out, close)?; + Ok(close) +} + +// ===== GET /api/font-meta(对齐 backend/routes/font_meta.ts + font_util/font_meta.ts)===== + +/// 元数据版本指纹(算法变更后 bump 使磁盘缓存失效) +pub const META_VERSION: u32 = 3; + +/// 字符集覆盖条目 +#[derive(Clone)] +struct CharsetCoverage { + key: String, + name: String, + total: u32, + covered: u32, + percent: f64, +} + +/// name 表提取的元信息 +#[derive(Clone, Default)] +struct FontInfo { + copyright: Option, + family: Option, + subfamily: Option, + unique_id: Option, + full_name: Option, + version: Option, + post_script: Option, + trademark: Option, + manufacturer: Option, + designer: Option, + description: Option, + vendor_url: Option, + designer_url: Option, + license: Option, + license_url: Option, +} + +/// 码位连续区间 +#[derive(Clone, Copy)] +struct CpRange { + start: u32, + end: u32, +} + +/// 完整字体元数据 +struct FontMeta { + total_code_points: u32, + coverage: Vec, + ranges: Vec, + info: FontInfo, +} + +/// 人工配置(font-config.json 单条目;key 为 camelCase 字段名) +#[derive(Clone, Default)] +struct UserConfig { + display_name: Option, + description: Option, + tags: Option>, + homepage: Option, + preview_text: Option, + body_title: Option, + body_text: Option, + charset_preview: Option, +} + +/// 元数据进程缓存(key = font_path) +static META_CACHE: Mutex>>> = Mutex::new(None); + +/// 闭包访问元数据缓存(惰性初始化) +fn with_meta_cache(f: impl FnOnce(&mut HashMap>) -> R) -> R { + let mut g = META_CACHE.lock().unwrap(); + f(g.get_or_insert_with(HashMap::new)) +} + +/// 人工配置缓存(font-config.json,mtime 检测变更) +struct UserConfigState { + map: HashMap, + mtime_ns: i128, +} + +static USER_CONFIG: Mutex> = Mutex::new(None); + +/// 闭包访问配置状态(惰性初始化) +fn with_user_config(f: impl FnOnce(&mut UserConfigState) -> R) -> R { + let mut g = USER_CONFIG.lock().unwrap(); + if g.is_none() { + *g = Some(UserConfigState { map: HashMap::new(), mtime_ns: 0 }); + } + f(g.as_mut().unwrap()) +} +const CONFIG_PATH: &str = "font/font-config.json"; + +/// 码位位集(全部 Unicode 码位空间) +struct CpBits { + words: Vec, // 0x110000 bits +} + +impl CpBits { + fn new() -> CpBits { + CpBits { words: vec![0; (0x110000 + 63) / 64] } + } + fn set(&mut self, cp: usize) { + self.words[cp / 64] |= 1u64 << (cp % 64); + } + fn is_set(&self, cp: usize) -> bool { + self.words[cp / 64] & (1u64 << (cp % 64)) != 0 + } + fn count(&self) -> u32 { + self.words.iter().map(|w| w.count_ones()).sum() + } + /// 升序遍历已置位码位 + fn iter_set(&self) -> impl Iterator + '_ { + (0..0x110000u32).filter(|&cp| self.is_set(cp as usize)) + } +} + +/// ttf/otf 表目录条目 +fn read_table_entry(data: &[u8], tag: &[u8; 4]) -> Option<(u32, u32)> { + if data.len() < 12 { + return None; + } + let num_tables = ((data[4] as u16) << 8) | data[5] as u16; + if num_tables == 0 || num_tables > 100 { + return None; + } + for i in 0..num_tables as usize { + let rec = 12 + i * 16; + if rec + 16 > data.len() { + return None; + } + if &data[rec..rec + 4] == tag { + let off = |k: usize| ((data[rec + k] as u32) << 24) | ((data[rec + k + 1] as u32) << 16) | ((data[rec + k + 2] as u32) << 8) | data[rec + k + 3] as u32; + return Some((off(8), off(12))); + } + } + None +} + +fn ru16(data: &[u8], i: usize) -> u16 { + ((data[i] as u16) << 8) | data[i + 1] as u16 +} + +fn ru32(data: &[u8], i: usize) -> u32 { + ((data[i] as u32) << 24) | ((data[i + 1] as u32) << 16) | ((data[i + 2] as u32) << 8) | data[i + 3] as u32 +} + +/// glyph 有效性验证器:TrueType 查 loca 非空轮廓;CFF 恒真(对齐 createGlyphValidator) +struct GlyphValidator<'a> { + data: &'a [u8], + loca_base: usize, + loca_format: u16, + is_ttf: bool, +} + +impl GlyphValidator<'_> { + fn has_glyph(&self, gid: u32) -> bool { + if !self.is_ttf { + return true; + } + if self.loca_format == 0 { + let lo_i = self.loca_base + gid as usize * 2; + let hi_i = lo_i + 2; + if hi_i + 2 > self.data.len() { + return false; + } + let start = ru16(self.data, lo_i) as u64 * 2; + let end = ru16(self.data, hi_i) as u64 * 2; + return end > start; + } + let lo_i = self.loca_base + gid as usize * 4; + let hi_i = lo_i + 4; + if hi_i + 4 > self.data.len() { + return false; + } + let start = ru32(self.data, lo_i); + let end = ru32(self.data, hi_i); + end > start + } +} + +fn create_glyph_validator(data: &[u8]) -> GlyphValidator<'_> { + let glyf = read_table_entry(data, b"glyf"); + let loca = read_table_entry(data, b"loca"); + let head = read_table_entry(data, b"head"); + let (Some(_glyf), Some(loca), Some(head)) = (glyf, loca, head) else { + // CFF 字体:cmap 有映射即有效 + return GlyphValidator { data, loca_base: 0, loca_format: 0, is_ttf: false }; + }; + let hf = head.0 as usize + 50; + let loca_format: u16 = if hf + 2 <= data.len() { ru16(data, hf) } else { 0 }; + GlyphValidator { data, loca_base: loca.0 as usize, loca_format, is_ttf: true } +} + +/// format4 收集(对齐 collectFormat4:gid≠0 且 loca 非空才计入) +fn collect_format4(data: &[u8], sub_off: usize, cps: &mut CpBits, gv: &GlyphValidator<'_>) { + if sub_off + 14 > data.len() { + return; + } + let seg_count = ru16(data, sub_off + 6) as usize / 2; + let end_code_base = sub_off + 14; + let start_code_base = end_code_base + seg_count * 2 + 2; + let id_delta_base = start_code_base + seg_count * 2; + let id_range_offset_base = id_delta_base + seg_count * 2; + + for i in 0..seg_count { + let e_i = end_code_base + i * 2; + if e_i + 2 > data.len() { + break; + } + let end = ru16(data, e_i); + let s_i = start_code_base + i * 2; + if s_i + 2 > data.len() { + break; + } + let start = ru16(data, s_i); + // 0xFFFF 哨兵 segment 跳过 + if start == 0xFFFF { + continue; + } + let d_i = id_delta_base + i * 2; + if d_i + 2 > data.len() { + break; + } + let id_delta = ru16(data, d_i); + let ro_i = id_range_offset_base + i * 2; + if ro_i + 2 > data.len() { + break; + } + let id_range_offset = ru16(data, ro_i); + + let mut cp: u32 = start as u32; + while cp <= end as u32 { + if id_range_offset == 0 { + let gid = (cp.wrapping_add(id_delta as u32)) & 0xFFFF; + if gid != 0 && gv.has_glyph(gid as u32) { + cps.set(cp as usize); + } + } else { + let glyph_off = id_range_offset_base + i * 2 + id_range_offset as usize + (cp - start as u32) as usize * 2; + if glyph_off + 2 > data.len() { + break; + } + let glyph_id = ru16(data, glyph_off); + let gid = (glyph_id.wrapping_add((cp.wrapping_add(id_delta as u32)) as u16)) & 0xFFFF; + if glyph_id != 0 && gid != 0 && gv.has_glyph(gid as u32) { + cps.set(cp as usize); + } + } + cp += 1; + } + } +} + +/// format12 收集(对齐 collectFormat12:逐 cp 验证 loca 非空) +fn collect_format12(data: &[u8], sub_off: usize, cps: &mut CpBits, gv: &GlyphValidator<'_>) { + if sub_off + 16 > data.len() { + return; + } + let n_groups = ru32(data, sub_off + 12); + let groups_base = sub_off + 16; + for i in 0..n_groups { + let g_off = groups_base + i as usize * 12; + if g_off + 12 > data.len() { + break; + } + let g_start = ru32(data, g_off); + let g_end = ru32(data, g_off + 4); + let g_gid = ru32(data, g_off + 8); + let mut cp = g_start; + while cp <= g_end { + let gid = g_gid.wrapping_add(cp - g_start); + if gid != 0 && gv.has_glyph(gid) { + cps.set(cp as usize); + } + cp += 1; + } + } +} + +/// 从字体字节收集所有有效 codepoint(对齐 extractCodePoints:fmt12 优先 + fmt4 补充) +fn extract_code_points(data: &[u8]) -> CpBits { + let mut cps = CpBits::new(); + let Some(cmap) = read_table_entry(data, b"cmap") else { return cps }; + + let number_subtables = ru16(data, cmap.0 as usize + 2); + let mut fmt4_off: Option = None; + let mut fmt12_off: Option = None; + let mut dir = cmap.0 as usize + 4; + for _ in 0..number_subtables { + if dir + 8 > data.len() { + break; + } + let platform_id = ru16(data, dir); + let encoding_id = ru16(data, dir + 2); + let sub_rel = ru32(data, dir + 4); + let sub_off = cmap.0 as usize + sub_rel as usize; + if sub_off + 2 <= data.len() { + let format = ru16(data, sub_off); + if format == 12 && platform_id == 3 && encoding_id == 10 && fmt12_off.is_none() { + fmt12_off = Some(sub_off); + } else if format == 4 && platform_id == 3 && encoding_id == 1 && fmt4_off.is_none() { + fmt4_off = Some(sub_off); + } + } + dir += 8; + } + + let gv = create_glyph_validator(data); + if let Some(off) = fmt12_off { + collect_format12(data, off, &mut cps, &gv); + } + if let Some(off) = fmt4_off { + collect_format4(data, off, &mut cps, &gv); + } + cps +} + +/// 标准字符集(对齐 CHARSETS) +const CHARSETS: [(&str, &str, u32, u32); 7] = [ + ("ascii", "英文字母数字", 0x20, 0x7e), + ("commonHanzi", "常用汉字(约3500)", 0x4e00, 0x5bad), + ("cjkBasic", "CJK 基本汉字(20992)", 0x4e00, 0x9fff), + ("cjkExtA", "CJK 扩展A(罕用字)", 0x3400, 0x4dbf), + ("punctuation", "中文标点", 0x3000, 0x303f), + ("fullwidth", "全角字符", 0xff00, 0xffef), + ("cyrillic", "西里尔字母/俄文", 0x400, 0x4ff), +]; + +/// 计算各类字符集覆盖率(对齐 calcCoverage) +fn calc_coverage(cps: &CpBits) -> Vec { + CHARSETS + .iter() + .map(|&(key, name, start, end)| { + let mut covered: u32 = 0; + for cp in start..=end { + if cps.is_set(cp as usize) { + covered += 1; + } + } + let total = end - start + 1; + let percent = if total > 0 { + (covered as f64 / total as f64 * 1000.0).round() / 10.0 + } else { + 0.0 + }; + CharsetCoverage { key: key.to_string(), name: name.to_string(), total, covered, percent } + }) + .collect() +} + +/// codepoint 位集 → 连续区间数组(对齐 codePointsToRanges) +fn code_points_to_ranges(cps: &CpBits) -> Vec { + let mut ranges: Vec = Vec::new(); + let mut current: Option = None; + for cp in cps.iter_set() { + if let Some(c) = current { + if cp == c.end + 1 { + current = Some(CpRange { start: c.start, end: cp }); + continue; + } + ranges.push(c); + } + current = Some(CpRange { start: cp, end: cp }); + } + if let Some(c) = current { + ranges.push(c); + } + ranges +} + +/// UTF-16BE 码元流解码(对齐 decodeNameString platformID=3:代理对合成,孤立代理 → U+FFFD) +fn decode_utf16be(bytes: &[u8]) -> String { + let mut out = String::new(); + let mut i: usize = 0; + while i + 2 <= bytes.len() { + let unit = ((bytes[i] as u16) << 8) | bytes[i + 1] as u16; + if (0xd800..=0xdbff).contains(&unit) && i + 4 <= bytes.len() { + let lo = ((bytes[i + 2] as u16) << 8) | bytes[i + 3] as u16; + if (0xdc00..=0xdfff).contains(&lo) { + let cp: u32 = 0x10000 + ((unit as u32 - 0xd800) << 10) + (lo as u32 - 0xdc00); + out.push(char::from_u32(cp).unwrap_or('\u{fffd}')); + i += 4; // zig 分支内 i+=2 + 循环步进 i+=2 + continue; + } + } + if (0xd800..=0xdfff).contains(&unit) { + // 孤立代理(TS 此处抛 RangeError 属崩溃边界)→ 用 U+FFFD 保守替代 + out.push('\u{fffd}'); + } else if unit != 0 { + out.push(char::from_u32(unit as u32).unwrap_or('\u{fffd}')); + } + i += 2; + } + out +} + +/// 字节流按 UTF-8 lossy 解码(对齐 TextDecoder 默认:非法序列替换 U+FFFD) +fn decode_utf8_lossy(bytes: &[u8]) -> String { + let mut out = String::new(); + let mut i: usize = 0; + while i < bytes.len() { + let len = match utf8_seq_len(bytes[i]) { + Some(l) => l, + None => { + out.push('\u{fffd}'); + i += 1; + continue; + } + }; + if i + len > bytes.len() { + out.push('\u{fffd}'); + i += 1; + continue; + } + match std::str::from_utf8(&bytes[i..i + len]) { + Ok(t) => out.push_str(t), + Err(_) => out.push('\u{fffd}'), + } + i += len; + } + out +} + +/// name 表提取(对齐 extractFontInfo:优先级 Windows 英文 > Windows > Mac) +fn extract_font_info(data: &[u8]) -> FontInfo { + let Some(entry) = read_table_entry(data, b"name") else { return FontInfo::default() }; + let base = entry.0 as usize; + if base + 6 > data.len() { + return FontInfo::default(); + } + + let count = ru16(data, base + 2); + let string_offset = ru16(data, base + 4); + let storage_base = base + string_offset as usize; + + // EXTRACT_NAME_IDS 恰为 0~14,按下标收集 + let mut collected: [Option; 15] = Default::default(); + let mut priorities: [u8; 15] = [0; 15]; + + let record_base = base + 6; + for i in 0..count { + let rec = record_base + i as usize * 12; + if rec + 12 > data.len() { + break; + } + let platform_id = ru16(data, rec); + let encoding_id = ru16(data, rec + 2); + let language_id = ru16(data, rec + 4); + let name_id = ru16(data, rec + 6); + let length = ru16(data, rec + 8); + let offset = ru16(data, rec + 10); + + if name_id >= 15 { + continue; + } + + let priority: u8 = if platform_id == 3 && language_id == 0x0409 { + 4 + } else if platform_id == 3 && encoding_id == 1 { + 3 + } else if platform_id == 3 { + 2 + } else if platform_id == 1 { + 1 + } else { + 0 + }; + if collected[name_id as usize].is_some() && priorities[name_id as usize] >= priority { + continue; + } + + let str_off = storage_base + offset as usize; + if str_off + length as usize > data.len() { + // 对齐 decodeNameString 越界返回 ""(不覆盖已有值) + continue; + } + let raw = &data[str_off..str_off + length as usize]; + let text = if platform_id == 3 { + decode_utf16be(raw) + } else { + decode_utf8_lossy(raw) + }; + if !text.is_empty() { + collected[name_id as usize] = Some(text); + priorities[name_id as usize] = priority; + } + } + + let mut c = collected.into_iter(); + FontInfo { + copyright: c.next().unwrap(), + family: c.next().unwrap(), + subfamily: c.next().unwrap(), + unique_id: c.next().unwrap(), + full_name: c.next().unwrap(), + version: c.next().unwrap(), + post_script: c.next().unwrap(), + trademark: c.next().unwrap(), + manufacturer: c.next().unwrap(), + designer: c.next().unwrap(), + description: c.next().unwrap(), + vendor_url: c.next().unwrap(), + designer_url: c.next().unwrap(), + license: c.next().unwrap(), + license_url: c.next().unwrap(), + } +} + +/// 完整元数据提取(对齐 extractFontMeta) +fn extract_font_meta(data: &[u8]) -> FontMeta { + let cps = extract_code_points(data); + FontMeta { + total_code_points: cps.count(), + coverage: calc_coverage(&cps), + ranges: code_points_to_ranges(&cps), + info: extract_font_info(data), + } +} + +/// 写元数据 JSON(config 为 None 时输出磁盘缓存形态;字段顺序对齐 TS JSON.stringify) +fn write_meta_json(meta: &FontMeta, config: Option<&UserConfig>) -> String { + let mut w = String::new(); + w.push_str(&format!( + "{{\"metaVersion\":{},\"totalCodePoints\":{},\"coverage\":[", + META_VERSION, meta.total_code_points + )); + for (i, c) in meta.coverage.iter().enumerate() { + if i > 0 { + w.push(','); + } + w.push_str("{\"key\":"); + w.push_str(&json_stringify_str(&c.key)); + w.push_str(",\"name\":"); + w.push_str(&json_stringify_str(&c.name)); + w.push_str(&format!(",\"total\":{},\"covered\":{},\"percent\":", c.total, c.covered)); + w.push_str(&json_percent(c.percent)); + w.push('}'); + } + w.push_str("],\"ranges\":["); + for (i, r) in meta.ranges.iter().enumerate() { + if i > 0 { + w.push(','); + } + w.push_str(&format!("[{},{}]", r.start, r.end)); + } + w.push_str("],\"info\":{"); + let fields: [(&str, &Option); 15] = [ + ("copyright", &meta.info.copyright), + ("family", &meta.info.family), + ("subfamily", &meta.info.subfamily), + ("uniqueId", &meta.info.unique_id), + ("fullName", &meta.info.full_name), + ("version", &meta.info.version), + ("postScript", &meta.info.post_script), + ("trademark", &meta.info.trademark), + ("manufacturer", &meta.info.manufacturer), + ("designer", &meta.info.designer), + ("description", &meta.info.description), + ("vendorUrl", &meta.info.vendor_url), + ("designerUrl", &meta.info.designer_url), + ("license", &meta.info.license), + ("licenseUrl", &meta.info.license_url), + ]; + let mut first = true; + for (name, value) in fields { + if let Some(v) = value { + if !first { + w.push(','); + } + first = false; + w.push('"'); + w.push_str(name); + w.push_str("\":"); + w.push_str(&json_stringify_str(v)); + } + } + w.push('}'); + if let Some(c) = config { + w.push_str(",\"config\":{"); + let str_fields: [(&str, &Option); 7] = [ + ("displayName", &c.display_name), + ("description", &c.description), + ("homepage", &c.homepage), + ("previewText", &c.preview_text), + ("bodyTitle", &c.body_title), + ("bodyText", &c.body_text), + ("charsetPreview", &c.charset_preview), + ]; + let mut cfirst = true; + for (name, value) in str_fields { + if let Some(v) = value { + if !cfirst { + w.push(','); + } + cfirst = false; + w.push('"'); + w.push_str(name); + w.push_str("\":"); + w.push_str(&json_stringify_str(v)); + } + } + if let Some(tags) = &c.tags { + if !cfirst { + w.push(','); + } + w.push_str("\"tags\":["); + for (ti, t) in tags.iter().enumerate() { + if ti > 0 { + w.push(','); + } + w.push_str(&json_stringify_str(t)); + } + w.push(']'); + } + w.push('}'); + } + w.push('}'); + w +} + +/// mtime 是否变化(对齐 refreshUserConfig 的廉价检测) +fn refresh_user_config() { + with_user_config(|g| { + refresh_user_config_locked(g); + }); +} + +/// mtime 变更后重载(持锁段,对齐 refreshUserConfig 的廉价检测) +fn refresh_user_config_locked(g: &mut UserConfigState) { + let Ok(md) = std::fs::metadata(CONFIG_PATH) else { return }; + if !md.is_file() || md.len() == 0 { + return; + } + let mtime_ns: i128 = md + .modified() + .ok() + .and_then(|t| t.duration_since(UNIX_EPOCH).ok()) + .map(|d| d.as_nanos() as i128) + .unwrap_or(0); + if mtime_ns == g.mtime_ns { + return; + } + g.mtime_ns = mtime_ns; + + let Ok(raw) = std::fs::read_to_string(CONFIG_PATH) else { return }; + let Some(v) = json_parse(raw.trim()) else { return }; + let JsonValue::Obj(items) = v else { return }; + g.map.clear(); + for (key, val) in items { + // 非 object 值(类型化解析失败)整条跳过,对齐 Zig 两头解析路径 + let Some(uc) = user_config_from_json(&val) else { continue }; + g.map.insert(key, uc); + } +} + +/// JsonValue → UserConfig(存在但类型不符的字段使整条失败,对齐 Zig 类型化解析) +fn user_config_from_json(v: &JsonValue) -> Option { + if !matches!(v, JsonValue::Obj(_)) { + return None; + } + // 字符串字段提取(缺失 → None;类型不符 → 整条失败) + let s = |key: &str| -> Option> { + match v.get(key) { + Some(JsonValue::Str(x)) => Some(Some(x.clone())), + Some(_) => None, + None => Some(None), + } + }; + let tags = match v.get("tags") { + Some(JsonValue::Arr(items)) => { + let mut out: Vec = Vec::with_capacity(items.len()); + for it in items { + match it { + JsonValue::Str(x) => out.push(x.clone()), + _ => return None, + } + } + Some(out) + } + Some(_) => return None, + None => None, + }; + Some(UserConfig { + display_name: s("displayName")?, + description: s("description")?, + tags, + homepage: s("homepage")?, + preview_text: s("previewText")?, + body_title: s("bodyTitle")?, + body_text: s("bodyText")?, + charset_preview: s("charsetPreview")?, + }) +} + +/// 匹配 font-config.json 的 key:取 basename(对齐 fontBasename) +fn font_basename(font_path: &str) -> &str { + match font_path.rfind('/') { + Some(i) => &font_path[i + 1..], + None => font_path, + } +} + +/// {"error":"字体不存在: "}(JSON 转义) +fn build_not_found_json(font_name: &str) -> String { + format!("{{\"error\":\"字体不存在: {}\"}}", json_stringify_str(font_name)) +} + +/// 磁盘 .meta.json → FontMeta(版本指纹不匹配返回 None) +fn meta_from_disk_json(raw: &str) -> Option { + let v = json_parse(raw.trim())?; + let meta_version = v.get_u32("metaVersion")??; + if meta_version != META_VERSION { + return None; + } + let total = v.get_u32("totalCodePoints")??; + + let JsonValue::Arr(cov_arr) = v.get("coverage")? else { return None }; + let mut coverage: Vec = Vec::with_capacity(cov_arr.len()); + for item in cov_arr { + let key = item.get_str("key")??; + let name = item.get_str("name")??; + let total_c = item.get_u32("total")??; + let covered = item.get_u32("covered")??; + let percent = match item.get("percent")? { + JsonValue::Num(n) => *n, + _ => return None, + }; + coverage.push(CharsetCoverage { + key: key.to_string(), + name: name.to_string(), + total: total_c, + covered, + percent, + }); + } + + let JsonValue::Arr(rng_arr) = v.get("ranges")? else { return None }; + let mut ranges: Vec = Vec::with_capacity(rng_arr.len()); + for item in rng_arr { + let JsonValue::Arr(pair) = item else { return None }; + if pair.len() != 2 { + return None; + } + let start = pair_u32(&pair[0])?; + let end = pair_u32(&pair[1])?; + ranges.push(CpRange { start, end }); + } + + let info_v = v.get("info")?; + let opt = |key: &str| info_v.get_str(key).flatten().map(|s| s.to_string()); + let info = FontInfo { + copyright: opt("copyright"), + family: opt("family"), + subfamily: opt("subfamily"), + unique_id: opt("uniqueId"), + full_name: opt("fullName"), + version: opt("version"), + post_script: opt("postScript"), + trademark: opt("trademark"), + manufacturer: opt("manufacturer"), + designer: opt("designer"), + description: opt("description"), + vendor_url: opt("vendorUrl"), + designer_url: opt("designerUrl"), + license: opt("license"), + license_url: opt("licenseUrl"), + }; + + Some(FontMeta { total_code_points: total, coverage, ranges, info }) +} + +/// ranges 数组元素取 u32 +fn pair_u32(v: &JsonValue) -> Option { + match v { + JsonValue::Num(n) if *n >= 0.0 && *n <= u32::MAX as f64 && n.fract() == 0.0 => Some(*n as u32), + _ => None, + } +} + +pub fn handle_font_meta( + stream: &mut TcpStream, + dirs: &[String], + query: &str, + close: bool, +) -> io::Result { + let mut font_name = String::new(); + for kv in query.split('&') { + let Some(eq) = kv.find('=') else { continue }; + if &kv[..eq] == "font" { + if let Ok(s) = String::from_utf8(http::url_decode(&kv[eq + 1..])) { + font_name = s; + } + } + } + if font_name.is_empty() { + http::send_json(stream, 400, "{\"error\":\"缺少 font 参数\"}", close)?; + return Ok(close); + } + let Some(font_path) = crate::find_font_path(dirs, &font_name) else { + let msg = build_not_found_json(&font_name); + http::send_json(stream, 404, &msg, close)?; + return Ok(close); + }; + + refresh_user_config(); + + // 1. 进程内存命中 → 2. 磁盘 .meta.json(版本指纹不匹配视为 miss)→ 3. 现算 + let mut meta: Option> = with_meta_cache(|m| m.get(&font_path).cloned()); + if meta.is_none() { + // 磁盘缓存(对齐 loadMetaFromDisk + META_VERSION 校验) + let meta_path = format!("{font_path}.meta.json"); + if let Ok(raw) = std::fs::read_to_string(&meta_path) { + meta = meta_from_disk_json(&raw).map(Arc::new); + } + if meta.is_none() { + // CPU/内存密集,复用子集化并发闸门(对齐 withMemoryGate + 503) + let memory_bytes = estimate_subset_memory(&font_path); + if !gate_acquire(queue_timeout_ms(), memory_bytes) { + http::send_text(stream, 503, "Server busy, please retry", close, &["Retry-After: 1"])?; + return Ok(close); + } + let extracted = match std::fs::read(&font_path) { + Ok(data) => { + let m = extract_font_meta(&data); + gate_release(memory_bytes); + Arc::new(m) + } + Err(_) => { + gate_release(memory_bytes); + http::send_text(stream, 404, "font not found", close, &[])?; + return Ok(close); + } + }; + meta = Some(extracted); + // 写盘缓存(失败不影响响应,对齐 saveMetaToDisk) + let disk_form = write_meta_json(meta.as_ref().unwrap(), None); + let _ = std::fs::write(&meta_path, disk_form); + } + // 进缓存(并发下二次检查,取先入者) + with_meta_cache(|map| { + if let Some(m) = map.get(&font_path) { + meta = Some(m.clone()); + } else { + map.insert(font_path.clone(), meta.clone().unwrap()); + } + }); + } + + // 人工配置(basename 匹配) + let config = with_user_config(|g| g.map.get(font_basename(&font_path)).cloned()); + + let body = write_meta_json(&meta.unwrap(), config.as_ref()); + http::send_json(stream, 200, &body, close)?; + Ok(close) +} + +// ===== 静态资源 + 字体详情页 SSR(对齐 backend/app.ts staticFileMiddleware + routes/font_detail.ts)===== + +const ROOT_DIR: &str = "dist"; + +/// SSG 模板占位符(对齐 src/placeholders.ts) +const FONT_NAME_PH: &str = "__FONT_NAME__"; +const FONT_SLUG_PH: &str = "__FONT_SLUG__"; +const ORIGIN_PH: &str = "__ORIGIN__"; + +/// MIME 映射(对齐 server/mime_type.ts;大小写敏感、缺省 application/octet-stream) +fn mime_type(ext: &str) -> &'static str { + const TABLE: [(&str, &str); 13] = [ + ("html", "text/html"), + ("css", "text/css"), + ("js", "application/javascript; charset=utf-8"), + ("json", "application/json"), + ("png", "image/png"), + ("jpg", "image/jpeg"), + ("jpeg", "image/jpeg"), + ("gif", "image/gif"), + ("svg", "image/svg+xml"), + ("woff", "font/woff"), + ("woff2", "font/woff2"), + ("ttf", "font/ttf"), + ("otf", "font/otf"), + ]; + for (e, m) in TABLE { + if e == ext { + return m; + } + } + "application/octet-stream" +} + +/// 带任意 Content-Type 的 200 响应(静态资源/SSR/SPA fallback 共用,含 CORS 头) +fn send_file_bytes(stream: &mut TcpStream, bytes: &[u8], content_type: &str, close: bool) -> io::Result<()> { + let mut head = format!( + "HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\n", + bytes.len() + ); + head.push_str("Access-Control-Allow-Origin: *\r\n"); + head.push_str("Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS\r\n"); + head.push_str("Access-Control-Allow-Headers: Content-Type, Authorization\r\n"); + head.push_str(&format!("Connection: {}\r\n\r\n", if close { "close" } else { "keep-alive" })); + http::write_all(stream, &[head.as_bytes(), bytes]) +} + +/// SSG 模板缓存(进程级读一次,对齐 templateCache) +static TEMPLATE_CACHE: Mutex> = Mutex::new(None); + +fn get_template() -> Option { + let mut g = TEMPLATE_CACHE.lock().unwrap(); + if let Some(t) = &*g { + return Some(t.clone()); + } + let path = format!("{ROOT_DIR}/fonts/{FONT_NAME_PH}/index.html"); + let raw = std::fs::read_to_string(&path).ok()?; + *g = Some(raw.clone()); + Some(raw) +} + +/// 查询字体是否存在(任意目录为文件即存在,对齐 getFontMeta) +fn font_exists(dirs: &[String], slug: &str) -> bool { + for dir in dirs { + if std::fs::metadata(format!("{dir}/{slug}")) + .map(|m| m.is_file()) + .unwrap_or(false) + { + return true; + } + } + false +} + +/// 字体详情页 SSR:读 SSG 模板替换占位符;模板不存在返回 None 走 SPA fallback +fn handle_font_detail(dirs: &[String], raw_path: &str) -> Option { + // 提取 slug:/fonts/令东齐伋复刻体.ttf → 令东齐伋复刻体.ttf(decodeURIComponent + 去尾部 /) + let mut slug = &raw_path["/fonts/".len()..]; + if slug.ends_with('/') { + slug = &slug[..slug.len() - 1]; + } + let slug = String::from_utf8(http::url_decode(slug)).ok()?; + + let template = get_template()?; + + let exists = font_exists(dirs, &slug); + + // 占位符 → 实际值(对齐 values:FONT_NAME/FONT_SLUG=slug,ORIGIN="") + let mut html = template.replace(FONT_NAME_PH, &slug); + html = html.replace(FONT_SLUG_PH, &slug); + html = html.replace(ORIGIN_PH, ""); + + // 字体不存在时在 head 注入 noindex(replace 只替换第一处,对齐 String.replace) + if !exists { + if let Some(pos) = html.find("") { + html = format!( + "{}\n{}", + &html[..pos], + &html[pos + "".len()..] + ); + } + } + Some(html) +} + +/// 解析静态文件:精确文件 → 目录/index.html → 读出字节(对齐 try 块三情况)。 +/// 返回 (字节, 实际落盘文件路径)——目录情形展开为 index.html, +/// Content-Type 须按实际文件扩展名判定(/fonts → dist/fonts/index.html → text/html; +/// 按原始路径判定会得 application/octet-stream,浏览器把页面导航当下载中止) +fn resolve_static(file_path: &str) -> Option<(Vec, String)> { + let md = std::fs::metadata(file_path).ok()?; + let mut resolved = file_path.to_string(); + if md.is_dir() { + resolved = format!("{file_path}/index.html"); + std::fs::metadata(&resolved).ok()?; + } + std::fs::read(&resolved).ok().map(|b| (b, resolved)) +} + +/// 文件扩展名(大小写敏感,对齐 split(".").pop()) +fn ext_of(path: &str) -> &str { + if let Some(i) = path.rfind('.') { + // 对齐 JS:无点或点后为空(路径以 / 结尾等)返回空串 + if i + 1 < path.len() && i > 0 && path.as_bytes()[i - 1] != b'/' { + return &path[i + 1..]; + } + } + "" +} + +/// 路径是否带后缀(对齐 /\.[^/]+$/:最后一段含 '.') +fn path_has_ext(path: &str) -> bool { + let last_seg = match path.rfind('/') { + Some(i) => &path[i + 1..], + None => path, + }; + last_seg.rfind('.').is_some() +} + +/// 静态资源中间件:GET → dist 静态/SSR/SPA fallback;非 GET → 405(对齐 staticFileMiddleware) +pub fn handle_static( + stream: &mut TcpStream, + dirs: &[String], + method: &str, + pathname: &str, + close: bool, +) -> io::Result { + if method != "GET" { + http::send_text(stream, 405, "Method Not Allowed", close, &[])?; + return Ok(close); + } + + let file_path = if pathname == "/" { + format!("{ROOT_DIR}/index.html") + } else { + format!("{ROOT_DIR}{pathname}") + }; + // 防止路径穿越:规范化后必须仍在 dist 目录内 + if !file_path.starts_with("dist/") && file_path != ROOT_DIR { + http::send_text(stream, 403, "403 Forbidden", close, &[])?; + return Ok(close); + } + + if let Some((bytes, resolved)) = resolve_static(&file_path) { + send_file_bytes(stream, &bytes, mime_type(ext_of(&resolved)), close)?; + return Ok(close); + } + + // 字体详情页 SSR:/fonts/xxx 无预渲染文件时读模板替换占位符 + if let Some(prefix) = pathname.strip_prefix("/fonts/") { + let _ = prefix; + if let Some(html) = handle_font_detail(dirs, pathname) { + send_file_bytes(stream, html.as_bytes(), "text/html; charset=utf-8", close)?; + return Ok(close); + } + } + + // 带后缀的请求不 fallback 直接 404;否则 SPA fallback 返回根 index.html + if path_has_ext(pathname) { + http::send_text(stream, 404, "404 Not Found", close, &[])?; + return Ok(close); + } + match std::fs::read(format!("{ROOT_DIR}/index.html")) { + Ok(fallback) => { + send_file_bytes(stream, &fallback, "text/html; charset=utf-8", close)?; + Ok(close) + } + Err(_) => { + http::send_text(stream, 500, "index.html missing", close, &[])?; + Ok(close) + } + } +} + +// ===== POST /api/glyph-match(原属 zig main.zig,NDJSON 事件)===== + +/// UTF-8 首码点(语义对齐 char.codePointAt(0);非法序列报错 → None) +fn first_code_point(s: &str) -> Option { + let b = s.as_bytes(); + if b.is_empty() { + return None; + } + let len = utf8_seq_len(b[0])?; + if b.len() < len { + return None; + } + std::str::from_utf8(&b[..len]).ok()?.chars().next().map(|c| c as u32) +} + +/// POST /api/glyph-match —— 逐字体光栅化评分,NDJSON 事件返回 +/// 语义对齐 backend/routes/glyph_match.ts 慢路径(无 .gidx 索引/聚类,直接从 +/// 原字体光栅化:子集不改动轮廓坐标,评分结果与 TS 索引位图逐位一致) +pub fn handle_glyph_match( + stream: &mut TcpStream, + dirs: &[String], + fonts: &FontCache, + body: &[u8], + close: bool, +) -> io::Result { + if body.is_empty() { + http::send_json(stream, 400, "{\"error\":\"request body required\"}", close)?; + return Ok(close); + } + let Ok(text) = std::str::from_utf8(body) else { + http::send_json(stream, 400, "{\"error\":\"invalid json\"}", close)?; + return Ok(close); + }; + let Some(parsed) = json_parse(text) else { + http::send_json(stream, 400, "{\"error\":\"invalid json\"}", close)?; + return Ok(close); + }; + // glyphs 数组(缺失按空处理;存在但类型不符 → invalid json,对齐 Zig 类型化解析) + let glyph_items: Vec = match parsed.get("glyphs") { + Some(JsonValue::Arr(a)) => a.clone(), + Some(_) => { + http::send_json(stream, 400, "{\"error\":\"invalid json\"}", close)?; + return Ok(close); + } + None => Vec::new(), + }; + // 先收条目(char/bitmap 类型不符 → invalid json,对齐 Zig 类型化解析) + let mut pairs: Vec<(String, String)> = Vec::with_capacity(glyph_items.len()); + for g in &glyph_items { + let JsonValue::Obj(_) = g else { + http::send_json(stream, 400, "{\"error\":\"invalid json\"}", close)?; + return Ok(close); + }; + let ch = match g.get_str("char") { + Some(Some(s)) => s.to_string(), + Some(None) => String::new(), + None => { + http::send_json(stream, 400, "{\"error\":\"invalid json\"}", close)?; + return Ok(close); + } + }; + let bm = match g.get_str("bitmap") { + Some(Some(s)) => s.to_string(), + Some(None) => String::new(), + None => { + http::send_json(stream, 400, "{\"error\":\"invalid json\"}", close)?; + return Ok(close); + } + }; + pairs.push((ch, bm)); + } + // 查询字形过滤语义对齐 TS:char 非空 + 位图恰为 4096 个 0/1 + let mut raws: Vec> = Vec::with_capacity(pairs.len()); + for (ch, bm) in &pairs { + let cp = if !ch.is_empty() { first_code_point(ch) } else { None }; + raws.push(gm::RawGlyph { char: ch.as_bytes(), bitmap: bm.as_bytes(), code_point: cp }); + } + let queries = gm::parse_query_glyphs(&raws); + if queries.is_empty() { + http::send_json(stream, 400, "{\"error\":\"glyphs required (char + 64x64 bitmap)\"}", close)?; + return Ok(close); + } + + // 收集候选字体(目录序 × readdir 序,语义对齐 listCandidateFonts) + struct Cand { + name: String, + path: String, + } + let mut cands: Vec = Vec::new(); + for dir in dirs { + let Ok(entries) = std::fs::read_dir(dir) else { continue }; + for entry in entries.flatten() { + if !entry_is_file(&entry, dir) { + continue; + } + let fname = entry.file_name(); + let Some(fname) = fname.to_str() else { continue }; + if !crate::has_font_ext(fname) { + continue; + } + cands.push(Cand { name: fname.to_string(), path: format!("{dir}/{fname}") }); + } + } + + // NDJSON 事件流(一次性收集全量再返回,语义对齐 collectMatchEvents 非流式形态) + let mut out = String::new(); + out.push_str(&format!("{{\"type\":\"start\",\"total\":{}}}\n", cands.len())); + + for cand in &cands { + // 逐字体内存闸门(对齐 glyph_match.ts 慢路径 withMemoryGate;排队超时仅 fontDone 跳过) + let est = estimate_subset_memory(&cand.path); + if !gate_acquire(queue_timeout_ms(), est) { + out.push_str(&format!("{{\"type\":\"fontDone\",\"font\":{}}}\n", json_stringify_str(&cand.name))); + continue; + } + + let font = match fonts.get_or_parse(&cand.path) { + Ok(f) => Some(f), + Err(_) => { + // 单个字体裁剪/解析失败不拖垮整个搜索(语义对齐 catch 后仅 fontDone) + None + } + }; + let Some(font) = font else { + out.push_str(&format!("{{\"type\":\"fontDone\",\"font\":{}}}\n", json_stringify_str(&cand.name))); + gate_release(est); + continue; + }; + // OTF(CFF 轮廓)不参与评分:TS 慢路径 subset.ttf 为 null 直接返回 [] + if !font.has_table(b"glyf") { + out.push_str(&format!("{{\"type\":\"fontDone\",\"font\":{}}}\n", json_stringify_str(&cand.name))); + gate_release(est); + continue; + } + + let mut started = false; + let mut has_match = false; + for q in &queries { + if font.glyph_id(q.code_point).is_none() { + if started { + out.push_str(&format!( + "{{\"type\":\"glyph\",\"font\":{},\"glyph\":null,\"missing\":true}}\n", + json_stringify_str(&cand.name) + )); + } + continue; + } + if !started { + started = true; + out.push_str(&format!( + "{{\"type\":\"font\",\"font\":{},\"subset\":\"\"}}\n", + json_stringify_str(&cand.name) + )); + } + let Some(bm) = gm::get_glyph_bitmap(&font, q.code_point) else { + out.push_str(&format!( + "{{\"type\":\"glyph\",\"font\":{},\"glyph\":null,\"missing\":true}}\n", + json_stringify_str(&cand.name) + )); + continue; + }; + has_match = true; + let mut dt_b: gm::DtT = [0.0; gm::GRID * gm::GRID]; + gm::distance_transform(&bm[..], &mut dt_b); + let score = gm::glyph_similarity(&q.bitmap[..], &bm[..], &q.dt[..], &dt_b[..]); + let ch = std::str::from_utf8(raws[q.query_index].char).unwrap_or(""); + out.push_str(&format!( + "{{\"type\":\"glyph\",\"font\":{},\"glyph\":{{\"char\":{},\"score\":{},\"queryIndex\":{}}},\"missing\":false}}\n", + json_stringify_str(&cand.name), + json_stringify_str(ch), + score, + q.query_index + )); + } + // 全部缺字的候选不展示,但仍计入完成进度 + if started && !has_match { + out.push_str(&format!( + "{{\"type\":\"glyph\",\"font\":{},\"glyph\":null,\"missing\":true}}\n", + json_stringify_str(&cand.name) + )); + } + out.push_str(&format!("{{\"type\":\"fontDone\",\"font\":{}}}\n", json_stringify_str(&cand.name))); + gate_release(est); + } + out.push_str("{\"type\":\"done\"}\n"); + + let head = format!( + "HTTP/1.1 200 OK\r\nContent-Type: application/x-ndjson; charset=utf-8\r\nContent-Length: {}\r\nCache-Control: no-cache\r\nX-Accel-Buffering: no\r\nAccess-Control-Allow-Origin: *\r\nAccess-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS\r\nAccess-Control-Allow-Headers: Content-Type, Authorization\r\nConnection: close\r\n\r\n", + out.len() + ); + http::write_all(stream, &[head.as_bytes(), out.as_bytes()])?; + Ok(true) // TS 显式 Connection: close +} + +// ===== 字体扩展名判定 ===== +// misc 模块内统一使用 crate::has_font_ext(main.rs 同名实现,语义对齐 main.zig hasFontExt) + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn utf16_len_utf8_bmp_and_astral() { + assert_eq!(utf16_len_utf8("abc"), 3); + assert_eq!(utf16_len_utf8("字体"), 2); + // U+1F600 → 2 个 UTF-16 码元 + assert_eq!(utf16_len_utf8("😀"), 2); + assert_eq!(utf16_len_utf8("a😀字"), 4); + } + + #[test] + fn json_stringify_escapes_like_json_stringify() { + assert_eq!(json_stringify_str("a\"b"), "\"a\\\"b\""); + assert_eq!(json_stringify_str("x\ny"), "\"x\\ny\""); + assert_eq!(json_stringify_str("\u{1}"), "\"\\u0001\""); + assert_eq!(json_stringify_str("字体"), "\"字体\""); + } + + #[test] + fn json_parse_basic() { + let v = json_parse(r#"{"a":1,"b":[true,null,"x\ny"],"c":{"d":-2.5}}"#).unwrap(); + assert_eq!(v.get("a"), Some(&JsonValue::Num(1.0))); + match v.get("b") { + Some(JsonValue::Arr(a)) => { + assert_eq!(a.len(), 3); + assert_eq!(a[0], JsonValue::Bool(true)); + // JSON 文本里的 \n 转义 → 真实换行 + assert_eq!(a[2], JsonValue::Str("x\ny".to_string())); + } + _ => panic!("b 应为数组"), + } + assert!(matches!(v.get("c").unwrap().get("d"), Some(JsonValue::Num(n)) if *n == -2.5)); + assert!(json_parse("{").is_none()); + assert!(json_parse("[1,]").is_none()); + } + + #[test] + fn json_parse_unicode_escape() { + let v = json_parse(r#""字""#).unwrap(); + assert_eq!(v, JsonValue::Str("字".to_string())); + // 代理对 U+1F600 + let v = json_parse(r#""😀""#).unwrap(); + assert_eq!(v, JsonValue::Str("😀".to_string())); + } + + #[test] + fn multipart_parse_basic() { + let ct = "multipart/form-data; boundary=XYZ"; + let body = b"--XYZ\r\nContent-Disposition: form-data; name=\"file\"; filename=\"a.ttf\"\r\nContent-Type: font/ttf\r\n\r\nBIN\r\n--XYZ--\r\n"; + let files = parse_multipart(ct, body).unwrap(); + assert_eq!(files.len(), 1); + assert_eq!(files[0].filename, b"a.ttf"); + assert_eq!(files[0].data, b"BIN"); + } + + #[test] + fn sanitize_filename_strips_traversal() { + assert_eq!(sanitize_filename("../../x/y..z.ttf"), "xyz.ttf"); + assert_eq!(sanitize_filename(".hidden.ttf"), ".hidden.ttf"); + assert_eq!(sanitize_filename(""), "unnamed.ttf"); + } + + #[test] + fn json_percent_formats_like_js() { + assert_eq!(json_percent(100.0), "100"); + assert_eq!(json_percent(12.3), "12.3"); + assert_eq!(json_percent(0.0), "0"); + } + + #[test] + fn first_code_point_semantics() { + assert_eq!(first_code_point("字"), Some(0x5b57)); + assert_eq!(first_code_point("ab"), Some('a' as u32)); + assert_eq!(first_code_point(""), None); + assert_eq!(first_code_point("\u{fffd}"), Some(0xfffd)); + } +} diff --git a/rust-spike/src/ttf.rs b/rust-spike/src/ttf.rs new file mode 100644 index 0000000..77a1ddb --- /dev/null +++ b/rust-spike/src/ttf.rs @@ -0,0 +1,2173 @@ +//! TTF 解析与子集化(零依赖,对译 zig-spike/src/ttf.zig) + +use std::collections::{HashMap, HashSet}; + +use crate::cff; +use crate::gsub; + +/// 解析错误(对译 Zig SubsetError 的 parse 侧子集;NotTtf 对外 422 "not a ttf font") +#[derive(Debug)] +pub enum ParseError { + /// 非 TTF/OTF 签名 + NotTtf, + /// 表目录越界 / cmap 缺失等结构错误 + BadTable, + /// 无可用 cmap + NoCmap, +} + +/// 子集化错误(对译 Zig error set;除 NotTtf 外的 BadTable/NoCmap/NoGlyphs/OtfUnsupported +/// 统一折叠为 SubsetFailed——对外同为 422 "subset failed") +#[derive(Debug)] +pub enum SubsetError { + /// 接口保留(main.rs match 穷尽性):NotTtf 只从 parse 侧产生,subset 入口的字体已解析通过 + #[allow(dead_code)] + NotTtf, + SubsetFailed, +} + +/// 大端 u16 读取(越界 panic,对齐 Zig 切片越界 let-it-crash) +fn ru16(b: &[u8], off: usize) -> u16 { + u16::from_be_bytes([b[off], b[off + 1]]) +} + +/// 大端 i16 读取(越界 panic,对齐 Zig) +fn ri16(b: &[u8], off: usize) -> i16 { + i16::from_be_bytes([b[off], b[off + 1]]) +} + +/// 大端 u32 读取(越界 panic,对齐 Zig) +fn ru32(b: &[u8], off: usize) -> u32 { + u32::from_be_bytes([b[off], b[off + 1], b[off + 2], b[off + 3]]) +} + +/// 写大端 u16(对译 ByteList.writeInt(u16)) +fn wb_u16(out: &mut Vec, v: u16) { + out.extend_from_slice(&v.to_be_bytes()); +} + +/// 写大端 i16(对译 ByteList.writeInt(i16)) +fn wb_i16(out: &mut Vec, v: i16) { + out.extend_from_slice(&v.to_be_bytes()); +} + +/// 写大端 u32(对译 ByteList.writeInt(u32)) +fn wb_u32(out: &mut Vec, v: u32) { + out.extend_from_slice(&v.to_be_bytes()); +} + +/// 4 字节对齐补零(对译 ByteList.pad4) +fn pad4(out: &mut Vec) { + while out.len() % 4 != 0 { + out.push(0); + } +} + +/// sfnt 表目录条目 +#[derive(Clone, Copy)] +struct TableDir { + /// 4 字节表标签 + tag: [u8; 4], + /// 原始 checksum(目录透传用) + checksum: u32, + /// 表体在原文件中的偏移 + offset: u32, + /// 表体字节长度 + length: u32, +} + +/// 解析后的字体(进程级缓存共享,只读;持有数据本体,表目录存偏移) +pub struct Font { + /// 原始字体字节(parse 时拷贝持有,供表透传/惰性切片) + pub data: Vec, + /// sfnt 表目录 + tables: Vec, + /// maxp.numGlyphs + pub num_glyphs: u16, + /// head.unitsPerEm(缺省 1000) + pub units_per_em: u16, + /// head.indexToLocFormat(0=short 1=long) + pub index_to_loc_format: u16, + /// 码点 → gid + pub cmap: HashMap, + /// gid → 码点反向索引:rev_pairs[rev_idx[gid]..rev_idx[gid+1]] 是该 gid 的全部码点 + pub rev_pairs: Vec, + /// rev_pairs 的分组前缀和(见 rev_pairs) + pub rev_idx: Vec, +} + +impl Font { + /// 解析 TTF/OTF(对译 Font.parse;失败返回 Err)。 + /// 拿走字节所有权:调用方 fs::read 的整文件缓冲直接进 Font,消除 to_vec 的整文件二次拷贝 + pub fn parse(data: Vec) -> Result { + if data.len() < 12 { + return Err(ParseError::NotTtf); + } + // 0x00010000 TrueType / 'true'(Mac 真实轮廓) / 'OTTO'(CFF 轮廓 OTF) + let sig = ru32(&data, 0); + if sig != 0x00010000 && sig != 0x74727565 && sig != 0x4F54544F { + return Err(ParseError::NotTtf); + } + let num_tables = ru16(&data, 4) as usize; + if data.len() < 12 + num_tables * 16 { + return Err(ParseError::BadTable); + } + let mut tables = Vec::with_capacity(num_tables); + for i in 0..num_tables { + let off = 12 + i * 16; + tables.push(TableDir { + tag: data[off..off + 4].try_into().unwrap(), + checksum: ru32(&data, off + 4), + offset: ru32(&data, off + 8), + length: ru32(&data, off + 12), + }); + } + let mut f = Font { + data, + tables, + num_glyphs: 0, + units_per_em: 1000, + index_to_loc_format: 0, + cmap: HashMap::new(), + rev_pairs: Vec::new(), + rev_idx: Vec::new(), + }; + f.num_glyphs = f.read_maxp_glyphs(); + f.index_to_loc_format = f.read_head_loc_format(); + f.units_per_em = f.read_head_upem(); + // 字段级不相交借用(f.data 只读 + f.cmap 可写),无需自引用结构 + Font::parse_cmap_impl(&f.data, &f.tables, f.num_glyphs, &mut f.cmap)?; + f.build_rev_index(); + Ok(f) + } + + /// 构建 gid→码点反向索引:计数排序(计数入 rev_idx + 前缀和 + 填充),parse 时一次, + /// 子集化每请求只查保留字形 + fn build_rev_index(&mut self) { + let mut idx = vec![0u32; self.num_glyphs as usize + 1]; + for &gid in self.cmap.values() { + idx[gid as usize + 1] += 1; + } + for i in 1..idx.len() { + idx[i] += idx[i - 1]; + } + let mut pairs = vec![0u32; self.cmap.len()]; + let mut cursor = idx.clone(); + for (&cp, &gid) in self.cmap.iter() { + pairs[cursor[gid as usize] as usize] = cp; + cursor[gid as usize] += 1; + } + self.rev_pairs = pairs; + self.rev_idx = idx; + } + + /// 查表体切片(越界表按缺失处理,对译 findTable) + fn find_table(&self, tag: &[u8; 4]) -> Option<&[u8]> { + for t in &self.tables { + if &t.tag == tag { + let end = t.offset as usize + t.length as usize; + if end <= self.data.len() { + return Some(&self.data[t.offset as usize..end]); + } + } + } + None + } + + /// 是否存在指定表(OTF 无 glyf,glyph-match 用此判 CFF 轮廓字体) + pub fn has_table(&self, tag: &[u8; 4]) -> bool { + self.find_table(tag).is_some() + } + + /// 码点 → gid 查询(cmap 访问入口,glyph-match 用) + #[allow(dead_code)] // R5' glyph-match 接入前未用 + pub fn glyph_id(&self, cp: u32) -> Option { + self.cmap.get(&cp).copied() + } + + fn read_maxp_glyphs(&self) -> u16 { + let maxp = match self.find_table(b"maxp") { + Some(t) => t, + None => return 0, + }; + if maxp.len() < 6 { + return 0; + } + ru16(maxp, 4) + } + + fn read_head_upem(&self) -> u16 { + let head = match self.find_table(b"head") { + Some(t) => t, + None => return 1000, + }; + if head.len() < 18 { + return 1000; + } + ru16(head, 18) + } + + fn read_head_loc_format(&self) -> u16 { + let head = match self.find_table(b"head") { + Some(t) => t, + None => return 0, + }; + if head.len() < 52 { + return 0; + } + ru16(head, 50) + } + + /// gid 的 loca 原始区间(无则是空字形) + fn loca_range(&self, gid: u16) -> Option<(u32, u32)> { + let loca = self.find_table(b"loca")?; + let g = gid as usize; + if self.index_to_loc_format == 0 { + if loca.len() < (g + 2) * 2 { + return None; + } + // u16 读出后乘 2 在 u32 域进行(locaRange u16 溢出修复语义) + let start = ru16(loca, g * 2) as u32 * 2; + let end = ru16(loca, (g + 1) * 2) as u32 * 2; + return Some((start, end)); + } + if loca.len() < (g + 2) * 4 { + return None; + } + Some((ru32(loca, g * 4), ru32(loca, (g + 1) * 4))) + } + + /// 复合字形递归收集引用分量(防环) + fn collect_components(&self, gid: u16, glyf: &[u8], out: &mut Vec) { + let Some((start, end)) = self.loca_range(gid) else { + return; + }; + if end <= start || end as usize > glyf.len() { + return; + } + let gdata = &glyf[start as usize..end as usize]; + if gdata.len() < 2 { + return; + } + let nc = ri16(gdata, 0); + if nc >= 0 || gdata.len() < 10 { + return; + } + let mut off = 10usize; + while off + 4 <= gdata.len() { + let flags_raw = ru16(gdata, off); + let comp_gid = ru16(gdata, off + 2); + let dup = out.iter().any(|&x| x == comp_gid); + if !dup && comp_gid != gid && comp_gid < self.num_glyphs { + out.push(comp_gid); + self.collect_components(comp_gid, glyf, out); + } + off += 4; + // ARG_1_AND_2_ARE_WORDS + off += if flags_raw & 0x0001 != 0 { 4 } else { 2 }; + if flags_raw & 0x0008 != 0 { + off += 2; // WE_HAVE_A_SCALE + } + if flags_raw & 0x0040 != 0 { + off += 4; // WE_HAVE_AN_X_AND_Y_SCALE + } + if flags_raw & 0x0080 != 0 { + off += 8; // WE_HAVE_A_TWO_BY_TWO + } + // MORE_COMPONENTS + if flags_raw & 0x0020 == 0 { + break; + } + } + } + + /// 文本涉及的 gid 集(gid 0 始终保留,升序) + pub fn collect_gids(&self, text: &str) -> Result, SubsetError> { + let mut gids: Vec = vec![0]; + let glyf = self.find_table(b"glyf"); + for ch in text.chars() { + let cp = ch as u32; + if let Some(&gid) = self.cmap.get(&cp) { + if !gids.contains(&gid) { + gids.push(gid); + } + if let Some(g) = glyf { + let mut tmp = Vec::new(); + self.collect_components(gid, g, &mut tmp); + for cg in tmp { + if !gids.contains(&cg) { + gids.push(cg); + } + } + } + } + } + if gids.len() <= 1 { + return Err(SubsetError::SubsetFailed); // NoGlyphs + } + gids.sort_unstable(); + Ok(gids) + } + + /// 种子 gid(TS probe 语义):gid 0 + 文本码点首次出现序的 cmap gid。 + /// 不排序——插入序决定 TS subsetGids 追加顺序即新 gid 编号,是 GSUB 对拍的前提。 + fn seed_gids(&self, text: &str) -> Vec { + let mut seeds: Vec = vec![0]; + let mut seen_cp: HashSet = HashSet::new(); + for ch in text.chars() { + let cp = ch as u32; + if !seen_cp.insert(cp) { + continue; + } + if let Some(&gid) = self.cmap.get(&cp) { + if !seeds.contains(&gid) { + seeds.push(gid); + } + } + } + seeds + } + + /// 解析 cmap(Unicode 子表 format4/12 合并;无命中报 NoCmap)。 + /// 拆为关联函数是为绕过 parse 阶段 data 未拷贝时的自借用问题。 + fn parse_cmap_impl(data: &[u8], tables: &[TableDir], num_glyphs: u16, cmap: &mut HashMap) -> Result<(), ParseError> { + let cmap_tbl = find_table_in(data, tables, b"cmap").ok_or(ParseError::NoCmap)?; + if cmap_tbl.len() < 4 { + return Err(ParseError::NoCmap); + } + let num_sub = ru16(cmap_tbl, 2) as usize; + for i in 0..num_sub { + let rec = &cmap_tbl[4 + i * 8..]; + if rec.len() < 8 { + break; + } + let platform = ru16(rec, 0); + let encoding = ru16(rec, 2); + let offset = ru32(rec, 4) as usize; + let is_unicode = (platform == 3 && (encoding == 1 || encoding == 10)) || platform == 0; + if !is_unicode || offset >= cmap_tbl.len() { + continue; + } + let sub = &cmap_tbl[offset..]; + if sub.len() < 2 { + continue; + } + let format = ru16(sub, 0); + match format { + 4 => parse_cmap4(sub, num_glyphs, cmap), + 12 => parse_cmap12(sub, num_glyphs, cmap), + _ => {} + } + } + if cmap.is_empty() { + return Err(ParseError::NoCmap); + } + Ok(()) + } +} + +/// 查表体切片(parse 阶段的自由函数版本,data 尚未被 Font 持有时使用) +fn find_table_in<'a>(data: &'a [u8], tables: &[TableDir], tag: &[u8; 4]) -> Option<&'a [u8]> { + for t in tables { + if &t.tag == tag { + let end = t.offset as usize + t.length as usize; + if end <= data.len() { + return Some(&data[t.offset as usize..end]); + } + } + } + None +} + +/// cmap format4 子表解析(对译 parseCmap4) +fn parse_cmap4(sub: &[u8], num_glyphs: u16, cmap: &mut HashMap) { + if sub.len() < 14 { + return; + } + let seg_count = ru16(sub, 6) as usize / 2; + let seg_end_off = 14usize; + let seg_start_off = seg_end_off + seg_count * 2 + 2; + let delta_off = seg_start_off + seg_count * 2; + let range_off = delta_off + seg_count * 2; + if sub.len() < range_off + seg_count * 2 { + return; + } + for seg in 0..seg_count { + let end_cp = ru16(sub, seg_end_off + seg * 2); + let start_cp = ru16(sub, seg_start_off + seg * 2); + let delta = ru16(sub, delta_off + seg * 2); + let ro = ru16(sub, range_off + seg * 2); + let mut cp: u32 = start_cp as u32; + while cp <= end_cp as u32 { + let mut do_break = false; + 'seg: { + // 罕见奇数 idRangeOffset,跳过 + if ro % 2 == 1 { + break 'seg; + } + let gid: u16 = if ro == 0 { + // @truncate(u32 加法) 取低 16 位(对齐 Zig @truncate(@as(u32,cp) +% delta)) + (cp.wrapping_add(delta as u32)) as u16 + } else { + let gid_off = range_off + seg * 2 + ro as usize + (cp - start_cp as u32) as usize * 2; + if gid_off + 2 > sub.len() { + if cp == 0xFFFF { + do_break = true; + } + break 'seg; + } + let g = ru16(sub, gid_off); + if g == 0 { + if cp == 0xFFFF { + do_break = true; + } + break 'seg; + } + (g.wrapping_add(delta)) as u16 + }; + if gid != 0 && gid < num_glyphs { + cmap.insert(cp, gid); + } + if cp == 0xFFFF { + do_break = true; + } + } + if do_break { + break; + } + cp += 1; + } + } +} + +/// cmap format12 子表解析(对译 parseCmap12) +fn parse_cmap12(sub: &[u8], num_glyphs: u16, cmap: &mut HashMap) { + if sub.len() < 16 { + return; + } + let num_groups = ru32(sub, 12); + for g in 0..num_groups as usize { + let rec = &sub[16 + g * 12..]; + if rec.len() < 12 { + break; + } + let start_cp = ru32(rec, 0); + let end_cp = ru32(rec, 4); + let start_gid = ru32(rec, 8); + let mut cp = start_cp; + while cp <= end_cp { + let gid = start_gid + (cp - start_cp); + if gid < num_glyphs as u32 { + // @truncate(u32→u16) 取低 16 位 + cmap.insert(cp, gid as u16); + } + if cp == 0x10FFFF { + break; + } + cp += 1; + } + } +} + +/// 简单字形轮廓点(绝对坐标) +#[derive(Clone, Copy, Debug)] +pub struct GlyfPt { + /// X 绝对坐标(font units) + pub x: i32, + /// Y 绝对坐标(font units) + pub y: i32, + /// 是否 on-curve 点 + pub on_curve: bool, +} + +/// 解析原字体 simple glyph 的绝对坐标点(按 contour 分组;语义对齐 fonteditor parseSimpleGlyf) +fn parse_simple_glyph(font: &Font, gid: u16) -> Option>> { + let glyf = font.find_table(b"glyf")?; + let (start, end) = font.loca_range(gid)?; + if end <= start || end as usize > glyf.len() { + return None; + } + let g = &glyf[start as usize..end as usize]; + if g.len() < 10 { + return None; + } + // nc 为负属损坏数据:Zig @intCast(i16 负数 → usize) 在 ReleaseFast 下为巨正值随后被 + // 长度检查拦下;此处提前判负走同一 None 出口,合法字体行为一致 + let nc_raw = ri16(g, 0); + if nc_raw < 1 { + return None; + } + let nc = nc_raw as usize; + if 10 + nc * 2 > g.len() { + return None; + } + let mut end_pts: Vec = Vec::with_capacity(nc); + let mut total: usize = 0; + for i in 0..nc { + let ep = ru16(g, 10 + i * 2); + if ep as usize + 1 > total { + total = ep as usize + 1; + } + end_pts.push(ep); + } + // 跳过 instructions + if 12 + nc * 2 + 2 > g.len() { + return None; + } + let instr_len = ru16(g, 10 + nc * 2) as usize; + let mut p = 12 + nc * 2 + instr_len; + // flags(含 REPEAT 展开) + let mut flags: Vec = Vec::with_capacity(total); + while flags.len() < total { + if p >= g.len() { + return None; + } + let flag = g[p]; + p += 1; + flags.push(flag); + if flag & 0x08 != 0 && flags.len() < total { + // REPEAT + if p >= g.len() { + return None; + } + let rep = g[p] as usize; + p += 1; + for _ in 0..rep { + if flags.len() >= total { + break; + } + flags.push(flag); + } + } + } + // 绝对坐标(delta 累加) + let mut xs: Vec = Vec::with_capacity(total); + let mut px: i32 = 0; + for &fl in &flags { + let mut dx: i32 = 0; + if fl & 0x02 != 0 { + // XSHORT + if p >= g.len() { + return None; + } + dx = g[p] as i32; + p += 1; + // XSAME=正 + if fl & 0x10 == 0 { + dx = -dx; + } + } else if fl & 0x10 == 0 { + // 非 XSHORT 且非 XSAME:16 位 + if p + 2 > g.len() { + return None; + } + dx = ri16(g, p) as i32; + p += 2; + } + px += dx; + xs.push(px); + } + let mut ys: Vec = Vec::with_capacity(total); + let mut py: i32 = 0; + for &fl in &flags { + let mut dy: i32 = 0; + if fl & 0x04 != 0 { + // YSHORT + if p >= g.len() { + return None; + } + dy = g[p] as i32; + p += 1; + // YSAME=正 + if fl & 0x20 == 0 { + dy = -dy; + } + } else if fl & 0x20 == 0 { + if p + 2 > g.len() { + return None; + } + dy = ri16(g, p) as i32; + p += 2; + } + py += dy; + ys.push(py); + } + // 按 contour 分组 + let mut contours: Vec> = Vec::new(); + let mut start = 0usize; + for &ep in &end_pts { + let end = ep as usize; + if end < start || end >= total { + break; + } + let pts: Vec = (start..=end) + .map(|k| GlyfPt { + x: xs[k], + y: ys[k], + on_curve: flags[k] & 0x01 != 0, + }) + .collect(); + contours.push(pts); + start = end + 1; + } + Some(contours) +} + +/// 解析 gid 的轮廓(simple 直接解析;compound 递归内联)。 +/// 语义对齐 fonteditor transformGlyfContours: +/// - 矩阵 F2DOT14 解码 raw/16384,行向量应用 px = x*a + y*c + e、py = x*b + y*d + f +/// - 舍入 (v + 0.5) | 0(向零截断) +/// - 点匹配型 component(非 ARGS_ARE_XY_VALUES)TS 侧按 e=f=0 处理并忽略匹配点,此处一致 +pub fn glyph_contours(font: &Font, gid: u16, depth: u8) -> Result>, SubsetError> { + // 防环(合法字体嵌套深度远小于此) + if depth > 8 { + return Err(SubsetError::SubsetFailed); // BadTable + } + let empty = Vec::new(); + let glyf = match font.find_table(b"glyf") { + Some(g) => g, + None => return Err(SubsetError::SubsetFailed), // BadTable + }; + let Some((start, end)) = font.loca_range(gid) else { + return Ok(empty); + }; + if end <= start || end as usize > glyf.len() { + return Ok(empty); + } + let g = &glyf[start as usize..end as usize]; + if g.len() < 10 { + return Ok(empty); + } + let nc = ri16(g, 0); + if nc >= 0 { + return Ok(parse_simple_glyph(font, gid).unwrap_or_default()); + } + // compound:逐 component 解析 + 变换 + let mut out: Vec> = Vec::new(); + let mut off = 10usize; + loop { + if off + 4 > g.len() { + break; + } + let flags = ru16(g, off); + let comp_gid = ru16(g, off + 2); + off += 4; + let arg1: i32; + let arg2: i32; + if flags & 0x0001 != 0 { + // ARG_1_AND_2_ARE_WORDS + if off + 4 > g.len() { + break; + } + arg1 = ri16(g, off) as i32; + arg2 = ri16(g, off + 2) as i32; + off += 4; + } else { + if off + 2 > g.len() { + break; + } + // u8 → i8 位重解释(对齐 Zig @bitCast) + arg1 = (g[off] as i8) as i32; + arg2 = (g[off + 1] as i8) as i32; + off += 2; + } + let mut sa: f64 = 1.0; + let mut sb: f64 = 0.0; + let mut sc: f64 = 0.0; + let mut sd: f64 = 1.0; + if flags & 0x0008 != 0 { + // WE_HAVE_A_SCALE + if off + 2 > g.len() { + break; + } + sa = ri16(g, off) as f64 / 16384.0; + sd = sa; + off += 2; + } else if flags & 0x0040 != 0 { + // WE_HAVE_AN_X_AND_Y_SCALE + if off + 4 > g.len() { + break; + } + sa = ri16(g, off) as f64 / 16384.0; + sd = ri16(g, off + 2) as f64 / 16384.0; + off += 4; + } else if flags & 0x0080 != 0 { + // WE_HAVE_A_TWO_BY_TWO + if off + 8 > g.len() { + break; + } + sa = ri16(g, off) as f64 / 16384.0; + sb = ri16(g, off + 2) as f64 / 16384.0; + sc = ri16(g, off + 4) as f64 / 16384.0; + sd = ri16(g, off + 6) as f64 / 16384.0; + off += 8; + } + // 非 XY 值(点匹配):与 TS 一致按 e=f=0 变换(忽略匹配点语义,罕见) + let te: f64 = if flags & 0x0002 != 0 { arg1 as f64 } else { 0.0 }; + let tf: f64 = if flags & 0x0002 != 0 { arg2 as f64 } else { 0.0 }; + let comp_contours = glyph_contours(font, comp_gid, depth + 1)?; + for src in comp_contours { + let pts: Vec = src + .iter() + .map(|pt| { + let fx = pt.x as f64; + let fy = pt.y as f64; + // @intFromFloat(@trunc(v + 0.5)):向零截断舍入 + GlyfPt { + x: (fx * sa + fy * sc + te + 0.5).trunc() as i32, + y: (fx * sb + fy * sd + tf + 0.5).trunc() as i32, + on_curve: pt.on_curve, + } + }) + .collect(); + out.push(pts); + } + // MORE_COMPONENTS + if flags & 0x0020 == 0 { + break; + } + } + Ok(out) +} + +/// 将点集写出为合法 simple glyph 字节(instruction 剥离,delta 短编码,无 REPEAT) +fn write_simple_glyph(out: &mut Vec, contours: &[Vec]) { + let mut total: usize = 0; + let mut x_min: i32 = i32::MAX; + let mut y_min: i32 = i32::MAX; + let mut x_max: i32 = i32::MIN; + let mut y_max: i32 = i32::MIN; + for c in contours { + for pt in c { + total += 1; + if pt.x < x_min { + x_min = pt.x; + } + if pt.y < y_min { + y_min = pt.y; + } + if pt.x > x_max { + x_max = pt.x; + } + if pt.y > y_max { + y_max = pt.y; + } + } + } + if total == 0 { + // 全空(罕见):写零轮廓 header + for _ in 0..5 { + wb_i16(out, 0); + } + return; + } + // @intCast(i32→i16):合法字形 bbox/contour 数均在 i16 域,超界同 Zig ReleaseFast 截断 + wb_i16(out, contours.len() as i16); + wb_i16(out, x_min as i16); + wb_i16(out, y_min as i16); + wb_i16(out, x_max as i16); + wb_i16(out, y_max as i16); + // endPtsOfContours + let mut acc: u16 = 0; + for c in contours { + acc = acc.wrapping_add(c.len() as u16); + wb_u16(out, acc - 1); + } + wb_u16(out, 0); // instructionLength = 0(hinting 剥离) + + // flags:短编码,无 REPEAT + let mut pts_flat: Vec = Vec::with_capacity(total); + for c in contours { + pts_flat.extend_from_slice(c); + } + let mut flags_buf: Vec = Vec::with_capacity(total); + let mut prev_x: i32 = 0; + let mut prev_y: i32 = 0; + for pt in &pts_flat { + let dx = pt.x - prev_x; + let dy = pt.y - prev_y; + let mut fl: u8 = if pt.on_curve { 0x01 } else { 0 }; + if dx == 0 { + fl |= 0x10; // XSAME(16 位零增量) + } else if dx > 0 && dx <= 255 { + fl |= 0x02 | 0x10; // XSHORT 正 + } else if dx < 0 && -dx <= 255 { + fl |= 0x02; // XSHORT 负 + } + if dy == 0 { + fl |= 0x20; + } else if dy > 0 && dy <= 255 { + fl |= 0x04 | 0x20; // YSHORT 正 + } else if dy < 0 && -dy <= 255 { + fl |= 0x04; // YSHORT 负 + } + flags_buf.push(fl); + prev_x = pt.x; + prev_y = pt.y; + } + for &fl in &flags_buf { + out.push(fl); + } + // x deltas + prev_x = 0; + for (i, pt) in pts_flat.iter().enumerate() { + let fl = flags_buf[i]; + let dx = pt.x - prev_x; + if fl & 0x02 != 0 { + out.push(dx.unsigned_abs() as u8); + } else if fl & 0x10 == 0 { + // @intCast(i32→i16):短编码未命中的 |dx| 必 ≤32767(合法字形),超界同 ReleaseFast 截断 + wb_i16(out, dx as i16); + } + prev_x = pt.x; + } + // y deltas + prev_y = 0; + for (i, pt) in pts_flat.iter().enumerate() { + let fl = flags_buf[i]; + let dy = pt.y - prev_y; + if fl & 0x04 != 0 { + out.push(dy.unsigned_abs() as u8); + } else if fl & 0x20 == 0 { + wb_i16(out, dy as i16); + } + prev_y = pt.y; + } +} + +/// 码点→新 gid 对 +#[derive(Clone, Copy)] +struct CpPair { + /// 码点 + cp: u32, + /// 子集后的新 gid + gid: u16, +} + +/// BLUE_ZONE_ANCHORS_MINIMAL 32 锚定码点(TS font.ts,blue zone 校准字符集) +const ANCHOR_CODEPOINTS: &str = "\u{4ED6}\u{4EEC}\u{4F60}\u{4F86}\u{5011}\u{5230}\u{548C}\u{5730}\u{5BF9}\u{5C0D}\u{5C31}\u{5E2D}\u{6211}\u{65F6}\u{6642}\u{6703}\u{6765}\u{70BA}\u{80FD}\u{8230}\u{8AAA}\u{8BF4}\u{8FD9}\u{9019}\u{9F4A}\u{519B}\u{8FD8}\u{8FDB}\u{9032}\u{904E}\u{9053}\u{9084}"; + +/// 判断文本是否含 CJK 码点(对齐 TS font.ts hasCJK:2e80-9fff / 3400-4dbf / f900-faff) +fn has_cjk(text: &str) -> bool { + for ch in text.chars() { + let cp = ch as u32; + if (0x2e80..=0x9fff).contains(&cp) || (0x3400..=0x4dbf).contains(&cp) || (0xf900..=0xfaff).contains(&cp) { + return true; + } + } + false +} + +/// 唯一码点数(对齐 TS [...new Set(textToCodePoints(s))]:重复字符只计一次) +fn unique_cp_count(text: &str) -> usize { + let mut seen: HashSet = HashSet::new(); + for ch in text.chars() { + seen.insert(ch as u32); + } + seen.len() +} + +/// P1 锚定字注入:唯一码点 <32 且含 CJK 时在文本尾部追加 32 锚定字 +/// (对齐 TS injectBlueZoneAnchors:Set 追加语义,首现序不变;字体中不存在的码点被子集管线自然忽略) +/// 返回 None 表示无需注入(原文本继续使用) +fn maybe_inject_anchors(text: &str) -> Option { + if unique_cp_count(text) >= 32 { + return None; + } + if !has_cjk(text) { + return None; + } + let mut s = String::with_capacity(text.len() + ANCHOR_CODEPOINTS.len()); + s.push_str(text); + s.push_str(ANCHOR_CODEPOINTS); + Some(s) +} + +/// 简单可靠子集化:重写 glyf/loca/cmap/maxp,其余表原样透传(head 强制 short loca)。 +/// font 为外部预解析结果(可跨请求缓存),本函数只读。输出 ttf 字节。 +/// gid→新 gid 哨兵数组映射(替代 HashMap<u16,u16>;MISS 用 u16::MAX) +struct GidMap { + inner: Vec, +} + +impl GidMap { + /// 构建:单次 memset + keep 线性写(keep 内不得含重复 old gid,由调用方保证) + fn build(keep: &[u16], num_glyphs: u16) -> GidMap { + let mut inner = vec![u16::MAX; num_glyphs.max(keep.iter().copied().max().unwrap_or(0)) as usize + 1]; + for (new, &old) in keep.iter().enumerate() { + inner[old as usize] = new as u16; + } + GidMap { inner } + } + + /// 查 old gid 的新编号;不在子集返回 None + fn get(&self, old: u16) -> Option { + let v = *self.inner.get(old as usize)?; + if v == u16::MAX { None } else { Some(v) } + } +} + +pub fn subset(font: &Font, text_in: &str) -> Result, SubsetError> { + // ===== P1 锚定字注入(对齐 TS font.ts fontSubsetToObject 入口语义)===== + let injected: Option = maybe_inject_anchors(text_in); + let text: &str = match &injected { + Some(b) => b, + None => text_in, + }; + // ===== CFF 轮廓 OTF:走 subsetOTF 组装路径(不写 glyf/loca,改写 CFF)===== + if ru32(&font.data, 0) == 0x4F54544F { + return subset_otf(font, text); + } + // ===== GSUB 路径:可达闭包并入 keep,keep 用 TS 插入序(0 + 码点出现序 + 可达序)===== + // TS 语义:subsetGids 不排序,插入序即新 gid 编号;GSUB 重映射依赖该编号,故此路径不排序。 + let gsub_tbl = font.find_table(b"GSUB"); + let use_gsub = gsub_tbl.is_some_and(|t| t.len() >= 10); + let keep: Vec; + let mut gsub_out: Option> = None; + let mut gpos_out: Option> = None; + if use_gsub { + let gt = gsub_tbl.unwrap(); + let seeds = font.seed_gids(text); + // 可达闭包(插入序含种子);版本不支持时 collect_reachable 返回空,退回种子序 + //(TS:extraSubsetGids=[]) + let reachable = gsub::collect_reachable(gt, &seeds).map_err(|_| SubsetError::SubsetFailed)?; + let keep_list: Vec = if !reachable.is_empty() { + reachable + } else { + seeds + }; + // compound 字形不追加组件 gid:TS 侧 compound2simpleglyf 将组件轮廓内联进父字形, + // subsetGids = 0 + 码点序种子 + reachable 插入序(组件内联在 glyf 写出阶段处理) + if keep_list.len() <= 1 { + return Err(SubsetError::SubsetFailed); // NoGlyphs + } + gsub_out = Some(gsub::subset_gsub(gt, &keep_list).map_err(|_| SubsetError::SubsetFailed)?); + // GPOS 子集化(同一 keep 插入序重映射);None(版本不支持/解析异常)时保留原始字节透传, + // 与 TS rewriteLayoutTablesForSubset 的 rewritten===null 分支语义一致 + if let Some(gpos_tbl) = font.find_table(b"GPOS") { + if gpos_tbl.len() >= 10 { + if let Ok(Some(gp)) = gsub::subset_gpos(gpos_tbl, &keep_list) { + gpos_out = Some(gp); + } + } + } + keep = keep_list; + } else { + // 无 GSUB:原有路径(排序升序,保持既有产物字节不变) + keep = font.collect_gids(text)?; + } + // gid→新 gid 映射:哨兵数组替代 HashMap(u16 键用 SipHash 纯开销; + // 对齐 Zig 版 Int32Array gid_lookup 经验:构建是单次 memset+线性写,查询 O(1) 无 hash) + let gid_map = GidMap::build(&keep, font.num_glyphs); + + let glyf = font.find_table(b"glyf").ok_or(SubsetError::SubsetFailed)?; // BadTable + // 预分配:按平均字形大小估计输出上界(消除 128 字形逐个 extend 的倍增 realloc 搬移; + // 实测零预分配时单次 subset 62 次 realloc 搬移 730KB,是 libc memcpy 热点主源) + let avg_glyph = { + let g = font.find_table(b"glyf").map(|t| t.len()).unwrap_or(0) as usize; + let n = font.num_glyphs.max(1) as usize; + (g / n).max(16) + }; + let mut new_glyf: Vec = Vec::with_capacity(keep.len() * avg_glyph); + let mut new_loca: Vec = Vec::with_capacity(keep.len() + 1); + + // 码点→新gid,按码点排序。 + // GSUB 路径:仅请求的码点(TS 语义:cmap 不含同 gid 的未请求码点); + // 无 GSUB 路径:保持既有 rev_pairs 全量码点行为(产物字节不变回归红线) + let mut cp_pairs: Vec = Vec::new(); + if gsub_out.is_some() { + // 重复码点不去重收集(同 cp 必同 gid),sort 后统一 dedup——省一个 HashSet + for ch in text.chars() { + let cp = ch as u32; + let Some(&old_gid) = font.cmap.get(&cp) else { + continue; + }; + let Some(new_gid) = gid_map.get(old_gid) else { + continue; + }; + cp_pairs.push(CpPair { cp, gid: new_gid }); + } + } else { + for (new_idx, &old_gid) in keep.iter().enumerate() { + let new_gid: u16 = new_idx as u16; + let start = font.rev_idx[old_gid as usize] as usize; + let end = font.rev_idx[old_gid as usize + 1] as usize; + for &cp in &font.rev_pairs[start..end] { + cp_pairs.push(CpPair { cp, gid: new_gid }); + } + } + } + cp_pairs.sort_by_key(|p| p.cp); + cp_pairs.dedup_by_key(|p| p.cp); + + // 新 glyf + loca(loca 存字节偏移,写出时按 short/long 格式转换) + // GSUB 路径 compound 字形内联为 simple(TS compound2simpleglyf 语义);无 GSUB 路径保持分量重映射透传 + for &old_gid in &keep { + new_loca.push(new_glyf.len() as u32); + let range = match font.loca_range(old_gid) { + None => { + // 零轮廓字形(TS writeZeroContoursGlyfData:true 语义):写 12B 空 header + new_glyf.extend_from_slice(&[0u8; 12]); + pad4(&mut new_glyf); + continue; + } + Some(r) => r, + }; + if range.1 - range.0 < 12 || range.1 as usize > glyf.len() { + // 不足 12B 的残留(legacy 空字形 loca 长度 2/10 等)按零轮廓处理 + new_glyf.extend_from_slice(&[0u8; 12]); + pad4(&mut new_glyf); + continue; + } + let gdata = &glyf[range.0 as usize..range.1 as usize]; + let nc = ri16(gdata, 0); + if nc < 0 { + if gsub_out.is_some() { + let contours = glyph_contours(font, old_gid, 0)?; + write_simple_glyph(&mut new_glyf, &contours); + } else { + append_composite_glyph(&mut new_glyf, gdata, &gid_map); + } + } else { + // P4 hinting 剥离(TS hinting:false 生产语义):simple 字形重组剥 instructions + append_simple_glyph_stripped(&mut new_glyf, gdata)?; + } + pad4(&mut new_glyf); + } + new_loca.push(new_glyf.len() as u32); + if new_glyf.is_empty() { + return Err(SubsetError::SubsetFailed); // NoGlyphs + } + // TS sizeof 语义:glyf 表 >65536 字节时用 long loca(indexToLocFormat=1) + let loc_format: u16 = if new_glyf.len() > 65536 { 1 } else { 0 }; + + // cmap 子表字节(format 4) + let mut cmap_bytes: Vec = Vec::new(); + write_cmap4(&mut cmap_bytes, &cp_pairs)?; + + // ===== 输出 sfnt ===== + struct OutTable { + tag: [u8; 4], + checksum: u32, + /// 透传表原始数据;重写表为生成字节 + src: Vec, + } + let mut all_tables: Vec = Vec::new(); + const REWRITTEN: [&[u8; 4]; 7] = [b"glyf", b"loca", b"cmap", b"maxp", b"post", b"hmtx", b"hhea"]; + // 透传白名单:对齐 TS 生产(fonteditor)输出表集合。其余表必须删除—— + // vhea/vmtx(竖排 metrics 按 numGlyphs 对齐,不重建即非法且全量 122KB)、 + // hdmx/LTSH/VDMX(设备相关度量按原 gid 布局,子集后语义失效且 OTS 校验 numGlyphs 一致性会拒)、 + // DSIG/FFTM(签名/杂表)、gasp、GDEF/morx/prop/feat(内容按 gid 索引,未 remap 即语义错误)。 + const PASSTHROUGH_OK: [&[u8; 4]; 3] = [b"head", b"OS/2", b"BASE"]; + for t in &font.tables { + // GSUB 路径:原始 GSUB/GPOS 不透传,改用子集化结果 + if gsub_out.is_some() && &t.tag == b"GSUB" { + continue; + } + if gpos_out.is_some() && &t.tag == b"GPOS" { + continue; + } + let is_rewrite = REWRITTEN.iter().any(|r| &t.tag == *r); + if !is_rewrite { + let keep_tag = PASSTHROUGH_OK.iter().any(|w| &t.tag == *w); + if !keep_tag { + continue; + } + all_tables.push(OutTable { + tag: t.tag, + checksum: t.checksum, + src: font.data[t.offset as usize..(t.offset + t.length) as usize].to_vec(), + }); + } + } + // P6 name 白名单重建(对齐 TS fonteditor 产物语义) + if let Some(nm) = font.find_table(b"name") { + let rebuilt_name = build_ttf_subset_name(nm)?; + all_tables.push(OutTable { tag: *b"name", checksum: 0, src: rebuilt_name }); + } + all_tables.push(OutTable { tag: *b"cmap", checksum: 0, src: cmap_bytes }); + all_tables.push(OutTable { tag: *b"glyf", checksum: 0, src: new_glyf }); + all_tables.push(OutTable { tag: *b"loca", checksum: 0, src: Vec::new() }); + // maxp v1.0:透传原字体 32 字节并仅改写 numGlyphs(对齐 TS fonteditor 语义)。 + // 不能合成全 0 极值:maxZones=0 等违反 OpenType 规范,Windows DirectWrite 校验拒绝 + // → 字形渲染空白(FreeType 不校验,SSIM/无头 chromium 验证体系测不出)。 + // 极值偏大无害(资源分配提示),指令相关字段随 hinting:false 剥离语义原样保留亦可。 + let maxp_src: Vec = match font.find_table(b"maxp") { + Some(m) if m.len() >= 32 && ru32(m, 0) == 0x00010000 => { + let mut v = m.to_vec()[..32].to_vec(); + v[4..6].copy_from_slice(&(keep.len() as u16).to_be_bytes()); + v + } + _ => { + let mut v = Vec::with_capacity(32); + wb_u32(&mut v, 0x00010000); + wb_u16(&mut v, keep.len() as u16); + v.resize(32, 0); + v + } + }; + all_tables.push(OutTable { tag: *b"maxp", checksum: 0, src: maxp_src }); + all_tables.push(OutTable { tag: *b"post", checksum: 0, src: Vec::new() }); + // hmtx 按 NEW gid 序重建(前 numberOfHMetrics 个新记录是 advance+lsb,其余仅 lsb)。 + // advance 继承:old gid >= 原始 nhm 的字形 advance = 原始 gid nhm-1 的 advance(spec 语义) + let mut num_hm_new: u32 = 0; + let mut new_hmtx: Vec = Vec::new(); + if let Some(hmtx) = font.find_table(b"hmtx") { + let hhea = font.find_table(b"hhea"); + let nhm: u32 = match hhea { + Some(h) if h.len() >= 36 => ru16(h, 34) as u32, + _ => 0, + }; + /// 原 hmtx 中 old gid 的 advance(spec 继承:≥nhm 复用 nhm-1 的) + fn adv_of(hm: &[u8], n: u32, old: u16) -> Option { + let src: u32 = if (old as u32) < n { old as u32 } else if n > 0 { n - 1 } else { 0 }; + let o = src as usize * 4; + if o + 2 > hm.len() { + return None; + } + Some(ru16(hm, o)) + } + /// 原 hmtx 中 old gid 的 lsb(≥nhm 走 lsb 数组区) + fn lsb_of(hm: &[u8], n: u32, old: u16) -> Option { + if (old as u32) < n { + let o = old as usize * 4 + 2; + if o + 2 > hm.len() { + return None; + } + return Some(ru16(hm, o)); + } + let o = n as usize * 4 + (old as usize - n as usize) * 2; + if o + 2 > hm.len() { + return None; + } + Some(ru16(hm, o)) + } + // P7 advance 折叠(对齐 TS fonteditor 产物实测语义):numberOfHMetrics = + // 最后一个与末位 advance 不同的位置 + 1(全同时折叠到 1);尾部等 advance + // 字形只写 lsb。思源全角全同 → numH=1,优设标点 numH=2。 + let advs: Vec = keep.iter().map(|&old_gid| adv_of(hmtx, nhm, old_gid).unwrap_or(0)).collect(); + // 折叠规则(TS 产物 121 例反推验证):从尾部裁掉与前一条 advance 相同的记录, + // 保留到第一条与前不同的记录为止;全相同折叠到 1。思源全角全同 → numH=1。 + let mut num_h: usize = keep.len(); + if !keep.is_empty() { + let mut i = keep.len() - 1; + while i > 0 && advs[i] == advs[i - 1] { + i -= 1; + } + num_h = i + 1; + } + for (new_gid, &old_gid) in keep.iter().enumerate() { + let lsb = lsb_of(hmtx, nhm, old_gid).unwrap_or(0); + if new_gid < num_h { + wb_u16(&mut new_hmtx, advs[new_gid]); + wb_u16(&mut new_hmtx, lsb); + } else { + wb_u16(&mut new_hmtx, lsb); + } + } + // hhea.numberOfHMetrics 必须与 hmtx 实际长记录数一致且 <= numGlyphs,否则 OTS 拒载。 + num_hm_new = num_h as u32; + } + all_tables.push(OutTable { tag: *b"hmtx", checksum: 0, src: new_hmtx }); + // hhea:透传 + patch numberOfHMetrics(偏移 +34),与 hmtx 实际长记录数一致(否则 OTS 拒载) + if let Some(hh) = font.find_table(b"hhea") { + let mut patched = hh.to_vec(); + if patched.len() >= 36 { + patched[34..36].copy_from_slice(&(num_hm_new as u16).to_be_bytes()); + } + all_tables.push(OutTable { tag: *b"hhea", checksum: 0, src: patched }); + } + // 子集化后的 GSUB(重映射 coverage/ClassDef/替换目标 gid,保留连字与上下文替换) + if let Some(go) = gsub_out { + all_tables.push(OutTable { tag: *b"GSUB", checksum: 0, src: go }); + } + // 子集化后的 GPOS(重映射 coverage/ClassDef/PairPos gid,保留标点压缩定位);None 时原始字节已在透传循环保留 + if let Some(go) = gpos_out { + all_tables.push(OutTable { tag: *b"GPOS", checksum: 0, src: go }); + } + all_tables.sort_by(|a, b| a.tag.cmp(&b.tag)); + + // 输出 sfnt 预分配:各表体之和 + 目录区上界(消除组装段倍增 realloc) + // (输出字形数 = keep.len(),maxp 重建处直接取 keep.len()) + let out_cap: usize = 16 * all_tables.len() + 4096 + + all_tables.iter().map(|t| t.src.len()).sum::(); + let mut out: Vec = Vec::with_capacity(out_cap); + + // header + let total_tables = all_tables.len(); + wb_u32(&mut out, 0x00010000); + wb_u16(&mut out, total_tables as u16); + let mut sr: u32 = 16; + let mut es: u16 = 0; + while sr * 2 <= (total_tables * 16) as u32 { + sr *= 2; + es += 1; + } + wb_u16(&mut out, sr as u16); + wb_u16(&mut out, es); + wb_u16(&mut out, (total_tables * 16 - sr as usize) as u16); + + // 计算表体偏移 + let mut offsets: Vec = Vec::with_capacity(total_tables); + let mut lengths: Vec = Vec::with_capacity(total_tables); + let mut body_off: u32 = (12 + total_tables * 16) as u32; + for (i, t) in all_tables.iter().enumerate() { + let mut len: u32 = t.src.len() as u32; + if &t.tag == b"loca" { + len = (new_loca.len() * if loc_format == 0 { 2 } else { 4 }) as u32; + } + if &t.tag == b"maxp" { + len = 32; + } + if &t.tag == b"post" { + len = 32; // format 3 + } + offsets.push(body_off); + lengths.push(len); + body_off = (body_off + len + 3) & !3u32; + let _ = i; + } + + // 目录条目 + for (i, t) in all_tables.iter().enumerate() { + out.extend_from_slice(&t.tag); + wb_u32(&mut out, t.checksum); + wb_u32(&mut out, offsets[i]); + wb_u32(&mut out, lengths[i]); + } + + // 表体 + for (i, t) in all_tables.iter().enumerate() { + while out.len() < offsets[i] as usize { + out.push(0); + } + if &t.tag == b"loca" { + // short 格式存 half-word 偏移;long 格式存字节偏移 + if loc_format == 0 { + for &v in &new_loca { + wb_u16(&mut out, (v / 2) as u16); + } + } else { + for &v in &new_loca { + wb_u32(&mut out, v); + } + } + } else if &t.tag == b"post" { + // post format 3(无字形名),全部填 0 除 version + wb_u32(&mut out, 0x00030000); + out.resize(out.len() + 28, 0); + } else { + out.extend_from_slice(&t.src); + if &t.tag == b"head" { + // indexToLocFormat 按 glyf 大小定(TS sizeof 语义)、glyphDataFormat=0(head 尾部 4 字节) + let n = out.len(); + out[n - 4..n - 2].copy_from_slice(&loc_format.to_be_bytes()); + out[n - 2..].copy_from_slice(&0u16.to_be_bytes()); + // checkSumAdjustment 清零:head 的目录 checksum 按 adjustment=0 计算(对齐 assemble_otto), + // 最终值在下方全表 checksum 汇总后回填。原字体旧值残留会使文件级 checksum 不变量失效 + let h0 = out.len() - t.src.len(); + out[h0 + 8..h0 + 12].fill(0); + } + } + pad4(&mut out); + } + + // ===== 表 checksum + head.checkSumAdjustment ===== + // Windows DirectWrite 校验表 checksum,全 0 会使字形在 Windows 浏览器渲染成空白 + // (FreeType 不校验,故 SSIM/无头 chromium 验证体系测不出);语义对齐 assemble_otto: + // 目录写各表最终字节的 checksum;adjustment = 0xB1B0AFBA - (目录区 sum + Σ 各表 checksum) + let mut tables_data_sum: u32 = 0; + for (i, _t) in all_tables.iter().enumerate() { + let cks = calc_table_checksum(&out[offsets[i] as usize..(offsets[i] + lengths[i]) as usize]); + tables_data_sum = tables_data_sum.wrapping_add(cks); + let r = 12 + i * 16; + out[r + 4..r + 8].copy_from_slice(&cks.to_be_bytes()); + } + let mut dir_sum: u32 = 0; + let dir_size = 12 + all_tables.len() * 16; + let mut di = 0usize; + while di < dir_size { + dir_sum = dir_sum.wrapping_add(ru32(&out, di)); + di += 4; + } + for (i, t) in all_tables.iter().enumerate() { + if &t.tag == b"head" { + let h0 = offsets[i] as usize; + let adjustment = 0xB1B0AFBAu32.wrapping_sub(dir_sum.wrapping_add(tables_data_sum)); + out[h0 + 8..h0 + 12].copy_from_slice(&adjustment.to_be_bytes()); + } + } + Ok(out) +} + +/// simple 字形剥 instructions 重组(P4 对齐 TS hinting:false:读侧不解析、写侧不输出 hinting): +/// 原样保留 numberOfContours+bbox+endPtsOfContours,instructionLength 写 0, +/// 直接跟 flags + 坐标字节。composite 字形(nc<0)无 instructions 不走此路径。 +fn append_simple_glyph_stripped(out: &mut Vec, g: &[u8]) -> Result<(), SubsetError> { + if g.len() < 10 { + return Err(SubsetError::SubsetFailed); // BadTable + } + let nc_raw = ri16(g, 0); + if nc_raw < 0 { + return Err(SubsetError::SubsetFailed); // BadTable + } + let ilen_off = 10 + nc_raw as usize * 2; + if ilen_off + 2 > g.len() { + return Err(SubsetError::SubsetFailed); // BadTable + } + let ilen = ru16(g, ilen_off) as usize; + let rest_off = ilen_off + 2 + ilen; + if rest_off > g.len() { + return Err(SubsetError::SubsetFailed); // BadTable + } + out.extend_from_slice(&g[..ilen_off]); + wb_u16(out, 0); // instructionLength = 0 + out.extend_from_slice(&g[rest_off..]); + Ok(()) +} + +/// TTF name 表白名单重建(P6 对齐 TS fonteditor 产物实测语义): +/// 内容取英文记录——优先 (3,1,1033) UTF-16BE,缺项补 (1,0,0) Latin-1; +/// nameId 限 {1,2,4,6,16,17}。输出统一两组记录:先 (1,0,0) Latin-1 组, +/// 再 (3,1,1033) UTF-16BE 组,内容相同(TS 产物实测:FiraCode 只有 p3 记录时 +/// 会合成 pid1 记录;简中 2052 / mac e25 等其他 lang 记录全部丢弃)。 +fn build_ttf_subset_name(nm: &[u8]) -> Result, SubsetError> { + const KEEP_IDS: [u16; 6] = [1, 2, 4, 6, 16, 17]; + if nm.len() < 6 { + return Err(SubsetError::SubsetFailed); // BadTable + } + let count = ru16(nm, 2) as usize; + let str_off = ru16(nm, 4) as usize; + if nm.len() < 6 + count * 12 { + return Err(SubsetError::SubsetFailed); // BadTable + } + // 每个白名单 nid 的内容(Latin-1 单字节序列),pass0 取 p3e1/1033,pass1 补 p1e0/0 + let mut content: [Option>; 6] = [None, None, None, None, None, None]; + for pass in 0..2u8 { + let (want_pid, want_eid, want_lid): (u16, u16, u16) = if pass == 0 { (3, 1, 1033) } else { (1, 0, 0) }; + for ri in 0..count { + let rec = &nm[6 + ri * 12..6 + ri * 12 + 12]; + let pid = ru16(rec, 0); + let eid = ru16(rec, 2); + let lid = ru16(rec, 4); + let nid = ru16(rec, 6); + let len = ru16(rec, 8) as usize; + let off = ru16(rec, 10) as usize; + if pid != want_pid || eid != want_eid || lid != want_lid { + continue; + } + for (ki, &kid) in KEEP_IDS.iter().enumerate() { + if kid == nid && content[ki].is_none() { + // 越界即 panic(对齐 Zig 切片 let-it-crash) + let raw = &nm[str_off + off..str_off + off + len]; + if pass == 0 { + // UTF-16BE → Latin-1(英文记录码点 <256,取低字节) + let dst: Vec = (0..len / 2).map(|j| raw[j * 2 + 1]).collect(); + content[ki] = Some(dst); + } else { + content[ki] = Some(raw.to_vec()); + } + } + } + } + } + let mut n_kept: usize = 0; + for c in &content { + if c.is_some() { + n_kept += 1; + } + } + let total_recs = n_kept * 2; + let mut out: Vec = Vec::new(); + wb_u16(&mut out, 0); // format 0 + wb_u16(&mut out, total_recs as u16); + wb_u16(&mut out, (6 + total_recs * 12) as u16); // stringOffset + let mut cur: usize = 0; // offset 相对 string storage 起点(spec 语义) + // pid1 组记录 + for (ki, &kid) in KEEP_IDS.iter().enumerate() { + if let Some(s) = &content[ki] { + wb_u16(&mut out, 1); + wb_u16(&mut out, 0); + wb_u16(&mut out, 0); + wb_u16(&mut out, kid); + wb_u16(&mut out, s.len() as u16); + wb_u16(&mut out, cur as u16); + cur += s.len(); + } + } + // pid3 组记录(UTF-16BE,长度翻倍) + for (ki, &kid) in KEEP_IDS.iter().enumerate() { + if let Some(s) = &content[ki] { + wb_u16(&mut out, 3); + wb_u16(&mut out, 1); + wb_u16(&mut out, 1033); + wb_u16(&mut out, kid); + wb_u16(&mut out, (s.len() * 2) as u16); + wb_u16(&mut out, cur as u16); + cur += s.len() * 2; + } + } + // 字符串区:pid1 Latin-1 + pid3 UTF-16BE + for c in &content { + if let Some(s) = c { + out.extend_from_slice(s); + } + } + for c in &content { + if let Some(s) = c { + for &ch in s { + wb_u16(&mut out, ch as u16); + } + } + } + Ok(out) +} + +/// 复合字形透传 + component gid 重映射(无 GSUB 路径) +fn append_composite_glyph(out: &mut Vec, gdata: &[u8], gid_map: &GidMap) { + out.extend_from_slice(&gdata[..10]); + let mut off = 10usize; + let mut more = true; + while more && off + 4 <= gdata.len() { + let flags_raw = ru16(gdata, off); + let comp_gid = ru16(gdata, off + 2); + let new_gid = gid_map.get(comp_gid).unwrap_or(0); + let mut extra: usize = 0; + if flags_raw & 0x0008 != 0 { + extra = 2; + } + if flags_raw & 0x0040 != 0 { + extra = 4; + } + if flags_raw & 0x0080 != 0 { + extra = 8; + } + let arg_len: usize = if flags_raw & 0x0001 != 0 { 4 } else { 2 }; + let seg_end = off + 4 + arg_len + extra; + if seg_end > gdata.len() { + break; + } + wb_u16(out, flags_raw); + wb_u16(out, new_gid); + out.extend_from_slice(&gdata[off + 4..seg_end]); + more = flags_raw & 0x0020 != 0; + off = seg_end; + } +} + +/// cmap format4 段(delta 已按 u16 存储位模式)(对译 CmapSeg) +#[derive(Clone, Copy)] +struct CmapSeg { + /// 段起始码点 + start: u32, + /// 段结束码点 + end: u32, + /// idDelta(u16 位模式) + delta: u16, +} + +/// cmap format12 group(BMP 外码点;连续码点且 gid 连续合并)(对译 Cmap12Group) +#[derive(Clone, Copy)] +struct Cmap12Group { + /// 组起始码点 + start: u32, + /// 组结束码点 + end: u32, + /// 组起始 gid + gid: u16, +} + +/// cmap(format 4,平台 3/1),段内 gid 线性(idRangeOffset=0) +fn write_cmap4(out: &mut Vec, pairs: &[CpPair]) -> Result<(), SubsetError> { + let mut segs: Vec = Vec::new(); + for p in pairs { + if let Some(last) = segs.last_mut() { + // @as(u16, @intCast(p.cp)):Zig ReleaseFast 下超 u16 静默截断,Rust `as` 同语义 + if p.cp == last.end + 1 && p.gid == last.delta.wrapping_add(p.cp as u16) { + last.end = p.cp; + continue; + } + } + segs.push(CmapSeg { + start: p.cp, + end: p.cp, + delta: p.gid.wrapping_sub(p.cp as u16), + }); + } + if segs.is_empty() { + return Err(SubsetError::SubsetFailed); // NoGlyphs + } + if segs.last().unwrap().end != 0xFFFF { + // start_gid=0 → idDelta = 0 -% 0xFFFF = 1 + segs.push(CmapSeg { start: 0xFFFF, end: 0xFFFF, delta: 1 }); + } + finish_cmap(out, &segs, pairs); + Ok(()) +} + +/// cmap format4 段序列化(公共尾部:header/format4 字段/endCodes/startCodes/idDelta/idRangeOffset) +fn write_cmap4_segments(out: &mut Vec, segs: &[CmapSeg]) { + let n = segs.len(); + let sub_len: u16 = (16 + n * 8) as u16; + // cmap header + 子表记录 + wb_u16(out, 0); + wb_u16(out, 1); + wb_u16(out, 3); + wb_u16(out, 1); + wb_u32(out, 12); + write_cmap4_subtable(out, segs, sub_len); +} + +/// 仅 format4 子表体(不含 cmap header/记录;header 由调用方按子表数量组装) +fn write_cmap4_subtable(out: &mut Vec, segs: &[CmapSeg], sub_len: u16) { + let n = segs.len(); + // format 4 + let mut sr: u16 = 2; + let mut es: u16 = 0; + while (sr as usize) * 2 <= n * 2 { + sr *= 2; + es += 1; + } + wb_u16(out, 4); + wb_u16(out, sub_len); + wb_u16(out, 0); // language + wb_u16(out, (n * 2) as u16); // segCountX2 + wb_u16(out, sr); + wb_u16(out, es); + wb_u16(out, (n * 2 - sr as usize) as u16); + for s in segs { + wb_u16(out, s.end as u16); + } + wb_u16(out, 0); // reservedPad + for s in segs { + wb_u16(out, s.start as u16); + } + for s in segs { + wb_u16(out, s.delta); + } + for _ in segs { + wb_u16(out, 0); // idRangeOffset=0 + } +} + +/// cmap 组装收尾:仅 BMP 码点 → 单 format4;含 BMP 外码点 → 补 format12 子表(platform 3/10)。 +/// 缺 format12 时 plane1+ 字形保留在 glyf/CFF 但 cmap 无映射 → 浏览器渲染 tofu。 +/// TS 生产语义(writeWindowsAllCodes / hasGLyfhsOver2Bytes):仅当存在 >2 字节码点才写 format12。 +fn finish_cmap(out: &mut Vec, segs: &[CmapSeg], pairs: &[CpPair]) { + let has_astral = pairs.iter().any(|p| p.cp > 0xFFFF); + if !has_astral { + write_cmap4_segments(out, segs); + return; + } + + // format4 子表体(BMP 段,segs 已含 0xFFFF 哨兵) + let mut sub4: Vec = Vec::new(); + write_cmap4_subtable(&mut sub4, segs, (16 + segs.len() * 8) as u16); + + // format12 子表:必须含全部码点(平台按 3/10 优先查找,只写 astral 会丢 BMP 映射); + // 连续码点且 gid 连续的合并为 group + let mut sub12: Vec = Vec::new(); + let mut groups: Vec = Vec::new(); + for p in pairs { + let mut merged = false; + if let Some(last) = groups.last_mut() { + // @intCast(p.cp - last.start):Zig ReleaseFast 下超 u16 静默截断,`as` 同语义 + if p.cp == last.end + 1 && p.gid == last.gid.wrapping_add((p.cp - last.start) as u16) { + last.end = p.cp; + merged = true; + } + } + if !merged { + groups.push(Cmap12Group { start: p.cp, end: p.cp, gid: p.gid }); + } + } + let g12_len: u32 = (16 + groups.len() * 12) as u32; + wb_u16(&mut sub12, 12); // format + wb_u16(&mut sub12, 0); // reserved + wb_u32(&mut sub12, g12_len); + wb_u32(&mut sub12, 0); // language + wb_u32(&mut sub12, groups.len() as u32); + for g in &groups { + wb_u32(&mut sub12, g.start); + wb_u32(&mut sub12, g.end); + wb_u32(&mut sub12, g.gid as u32); + } + + // header:两条子表记录(header 4B + 2×记录 8B = 20,format4 @20,format12 @20+sub4) + wb_u16(out, 0); // version + wb_u16(out, 2); // numTables + wb_u16(out, 3); + wb_u16(out, 1); + wb_u32(out, 20); + wb_u16(out, 3); + wb_u16(out, 10); + wb_u32(out, (20 + sub4.len()) as u32); + out.extend_from_slice(&sub4); + out.extend_from_slice(&sub12); +} + +/// OTF 路径专用的 cmap format4 构建:bug-for-bug 复刻 TS buildSubsetCmap 的合并判定。 +/// TS 差异:delta 存 (gid-cp)&0xffff 后用带符号展开 ((delta<<16)>>16) 与未掩码差值 +/// (e.gid-e.cp) 比较 —— 当 |gid-cp| > 32768 时 &0xffff 往返无法还原符号,合并必失败拆段 +/// (如 cp 65288/65289 gid 11/12:raw=-65277 ≠ s16(259)=259)。若用模 2^16 等价判定 +/// 会把这些段合并(-8B),与 TS 产物不一致。 +fn write_cmap4_otf(out: &mut Vec, pairs: &[CpPair]) -> Result<(), SubsetError> { + let mut segs: Vec = Vec::new(); + for p in pairs { + let mut merged = false; + if let Some(last) = segs.last_mut() { + // TS: (e.gid - e.cp) === ((last.delta << 16) >> 16),未掩码 i32 差值 vs 存储 delta 的 i16 位重解释 + // (OTF 路径 cp 已过滤 <0x10000,i32 差值不丢位) + let raw: i32 = p.gid as i32 - p.cp as i32; + let last_delta_s: i32 = (last.delta as i16) as i32; + if p.cp == last.end + 1 && raw == last_delta_s { + last.end = p.cp; + merged = true; + } + } + if !merged { + segs.push(CmapSeg { + start: p.cp, + end: p.cp, + // @truncate(u32 减法) 取低 16 位 + delta: (p.gid as u32).wrapping_sub(p.cp) as u16, + }); + } + } + if segs.is_empty() { + return Err(SubsetError::SubsetFailed); // NoGlyphs + } + // TS 哨兵段恒追加(不判 last.end) + segs.push(CmapSeg { start: 0xFFFF, end: 0xFFFF, delta: 1 }); + finish_cmap(out, &segs, pairs); + Ok(()) +} + +// =========================================================================== +// OTF(CFF 轮廓)子集化 —— 语义移植自 backend/font_util/otf-subset.ts(对译 subsetOTF) +// =========================================================================== + +/// OTF 组装用输出表(字节已成型,待排序封装) +struct OtfOutTable { + /// 4 字节表标签 + tag: [u8; 4], + /// 表体字节 + src: Vec, +} + +/// OTF 子集化主入口(对齐 otf-subset.ts subsetOTF,outType 恒 otf → 计算 checksum)。 +/// keep(新 gid 序)= [0] + 码点首现序种子 + GSUB 可达闭包追加(与 TS buildSubsetGids + reachable 合并一致)。 +/// 输出表集合固定:CFF/cmap/hmtx/maxp v0.5/post v3/head/hhea/OS-2?/name?/BASE?/vmtx+vhea?/GSUB?/GPOS?; +/// VORG/GDEF/DSIG 等其余表全部丢弃。 +fn subset_otf(font: &Font, text: &str) -> Result, SubsetError> { + let cff_tbl = font.find_table(b"CFF ").ok_or(SubsetError::SubsetFailed)?; // OtfUnsupported + let _cmap_tbl = font.find_table(b"cmap").ok_or(SubsetError::SubsetFailed)?; + let hmtx_tbl = font.find_table(b"hmtx").ok_or(SubsetError::SubsetFailed)?; + let hhea_tbl = font.find_table(b"hhea").ok_or(SubsetError::SubsetFailed)?; + let head_tbl = font.find_table(b"head").ok_or(SubsetError::SubsetFailed)?; + if !font.has_table(b"maxp") { + return Err(SubsetError::SubsetFailed); + } + + // 种子 gid:[0] + 文本码点首现序(TS buildSubsetGids 插入序,不排序) + let seeds = font.seed_gids(text); + if seeds.len() <= 1 { + return Err(SubsetError::SubsetFailed); // NoGlyphs + } + + // keep = 种子序 + GSUB 可达闭包(插入序);无 GSUB 时保持种子序(TS OTF 路径从不排序) + let gsub_tbl = font.find_table(b"GSUB"); + let use_gsub = gsub_tbl.is_some_and(|t| t.len() >= 10); + let keep: Vec; + let mut gsub_out: Option> = None; + let mut gpos_out: Option> = None; + if use_gsub { + let gt = gsub_tbl.unwrap(); + let reachable = gsub::collect_reachable(gt, &seeds).map_err(|_| SubsetError::SubsetFailed)?; + keep = if !reachable.is_empty() { reachable } else { seeds }; + gsub_out = Some(gsub::subset_gsub(gt, &keep).map_err(|_| SubsetError::SubsetFailed)?); + // GPOS:None(版本不支持)时整个表丢弃(TS OTF 路径语义,与 TTF 路径透传不同) + if let Some(gpos_tbl) = font.find_table(b"GPOS") { + if gpos_tbl.len() >= 10 { + if let Ok(Some(gp)) = gsub::subset_gpos(gpos_tbl, &keep) { + gpos_out = Some(gp); + } + } + } + } else { + keep = seeds; + } + // gid→新 gid 映射:哨兵数组替代 HashMap(u16 键用 SipHash 纯开销; + // 对齐 Zig 版 Int32Array gid_lookup 经验:构建是单次 memset+线性写,查询 O(1) 无 hash) + let gid_map = GidMap::build(&keep, font.num_glyphs); + + // cmap 输入对:文本码点首现序 → 新 gid;仅 BMP(format4 上限,TS buildSubsetCmap 过滤 cp>=0x10000) + let mut cp_pairs: Vec = Vec::new(); + { + // 重复码点不去重收集(同 cp 必同 gid),sort 后统一 dedup——省一个 HashSet + for ch in text.chars() { + let cp = ch as u32; + if cp == 0 || cp >= 0x10000 { + continue; + } + let Some(&old_gid) = font.cmap.get(&cp) else { + continue; + }; + let Some(new_gid) = gid_map.get(old_gid) else { + continue; + }; + cp_pairs.push(CpPair { cp, gid: new_gid }); + } + } + cp_pairs.sort_by_key(|p| p.cp); + cp_pairs.dedup_by_key(|p| p.cp); + + // 子集 CFF(失败 → 整体降级报错,与 TS 返回 null 降级对应;本服务无 fonteditor 回退路径) + let new_cff = cff::subset_cff(cff_tbl, &keep) + .map_err(|_| SubsetError::SubsetFailed)? + .ok_or(SubsetError::SubsetFailed)?; + + // cmap(format 4,delta 合并 + 哨兵段,与 TS buildSubsetCmap 字节等价,含其带符号 delta 的合并怪癖) + let mut cmap_bytes: Vec = Vec::new(); + write_cmap4_otf(&mut cmap_bytes, &cp_pairs)?; + + // hmtx 重建(尾部相同 advance 折叠为只写 lsb)+ hhea patch numberOfHMetrics + let num_hm: usize = if hhea_tbl.len() >= 36 { ru16(hhea_tbl, 34) as usize } else { 0 }; + let hmtx_res = build_subset_metrics(hmtx_tbl, num_hm, &keep); + let mut new_hhea = hhea_tbl.to_vec(); + new_hhea[34..36].copy_from_slice(&(hmtx_res.num_long as u16).to_be_bytes()); + + // head 透传 + checkSumAdjustment 清零(封装时回填) + let mut new_head = head_tbl.to_vec(); + if new_head.len() >= 12 { + new_head[8..12].fill(0); + } + + // OS/2 透传 + patch usFirstCharIndex/usLastCharIndex(+64/+66,请求码点的 BMP min/max; + // TS 用请求 codePoints 而非实际命中的,缺失字也计入范围) + let mut os2_out: Option> = None; + if let Some(os2) = font.find_table(b"OS/2") { + if os2.len() >= 68 { + let mut o = os2.to_vec(); + let mut min_cp: u16 = 0xffff; + let mut max_cp: u16 = 0; + let mut seen2: HashSet = HashSet::new(); + for ch in text.chars() { + let cp = ch as u32; + if !seen2.insert(cp) { + continue; + } + if cp > 0 && cp < 0x10000 { + if cp < min_cp as u32 { + min_cp = cp as u16; + } + if cp > max_cp as u32 { + max_cp = cp as u16; + } + } + } + if min_cp > max_cp { + min_cp = 0; + max_cp = 0xffff; + } + o[64..66].copy_from_slice(&min_cp.to_be_bytes()); + o[66..68].copy_from_slice(&max_cp.to_be_bytes()); + os2_out = Some(o); + } + } + + // name 白名单重建(nameId 1/2/4/6/16/17;先扫 p3e1 再补其他 platform) + let name_out: Option> = match font.find_table(b"name") { + Some(nm) => Some(build_otf_subset_name(nm)?), + None => None, + }; + + // BASE 透传(缺 BASE 会使 FreeType/OTS 走启发式基线,渲染系统性偏移) + let base_out: Option> = font.find_table(b"BASE").map(|b| b.to_vec()); + + // vhea/vmtx 成对出现才重建(垂直排版 metrics) + let vhea_tbl = font.find_table(b"vhea"); + let vmtx_tbl = font.find_table(b"vmtx"); + let mut vmtx_out: Option> = None; + let mut vhea_out: Option> = None; + if let (Some(vhea), Some(vmtx)) = (vhea_tbl, vmtx_tbl) { + let num_v: usize = if vhea.len() >= 36 { ru16(vhea, 34) as usize } else { 0 }; + let vmtx_res = build_subset_metrics(vmtx, num_v, &keep); + let mut vhea_new = vhea.to_vec(); + vhea_new[34..36].copy_from_slice(&(vmtx_res.num_long as u16).to_be_bytes()); + vmtx_out = Some(vmtx_res.bytes); + vhea_out = Some(vhea_new); + } + + // 组装表清单(VORG/GDEF/DSIG 等丢弃) + let mut tables: Vec = Vec::new(); + tables.push(OtfOutTable { tag: *b"CFF ", src: new_cff }); + tables.push(OtfOutTable { tag: *b"cmap", src: cmap_bytes }); + tables.push(OtfOutTable { tag: *b"hmtx", src: hmtx_res.bytes }); + tables.push(OtfOutTable { tag: *b"head", src: new_head }); + tables.push(OtfOutTable { tag: *b"hhea", src: new_hhea }); + // maxp v0.5:version(4) + numGlyphs(2) + let mut maxp6 = Vec::with_capacity(6); + wb_u32(&mut maxp6, 0x00005000); + wb_u16(&mut maxp6, keep.len() as u16); + tables.push(OtfOutTable { tag: *b"maxp", src: maxp6 }); + // post format 3(无字形名,32 字节全零除 version) + let mut post32 = vec![0u8; 32]; + post32[0..4].copy_from_slice(&0x00030000u32.to_be_bytes()); + tables.push(OtfOutTable { tag: *b"post", src: post32 }); + if let Some(o) = os2_out { + tables.push(OtfOutTable { tag: *b"OS/2", src: o }); + } + if let Some(nm) = name_out { + tables.push(OtfOutTable { tag: *b"name", src: nm }); + } + if let Some(b) = base_out { + tables.push(OtfOutTable { tag: *b"BASE", src: b }); + } + if let Some(v) = vmtx_out { + tables.push(OtfOutTable { tag: *b"vmtx", src: v }); + } + if let Some(v) = vhea_out { + tables.push(OtfOutTable { tag: *b"vhea", src: v }); + } + if let Some(g) = gsub_out { + tables.push(OtfOutTable { tag: *b"GSUB", src: g }); + } + if let Some(g) = gpos_out { + tables.push(OtfOutTable { tag: *b"GPOS", src: g }); + } + + let out = assemble_otto(&mut tables); + out +} + +/// hmtx/vmtx 重建结果:字节 + 压缩后的 numberOfHMetrics(需回填 hhea/vhea +34) +struct MetricsResult { + /// 重建后的 metrics 表字节 + bytes: Vec, + /// 折叠后的长记录数(numberOfHMetrics) + num_long: u32, +} + +/// 重建 hmtx/vmtx(语义对齐 otf-subset.ts buildSubsetMetrics): +/// 原始记录前 numberOfHMetrics 个完整(advance+lsb),其余仅 lsb(advance 复用最后一条); +/// 输出按尾部连续相同 advance 折叠(numberOfHMetrics = 最后一个不同 advance 的位置 + 1), +/// 渲染等价(浏览器对 gid>=numberOfHMetrics 复用最后 advance)。 +fn build_subset_metrics(metrics: &[u8], num_hm: usize, keep: &[u16]) -> MetricsResult { + let last_adv: u16 = if num_hm > 0 && num_hm * 4 + 2 <= metrics.len() { + ru16(metrics, (num_hm - 1) * 4) + } else { + 0 + }; + let mut advs: Vec = Vec::with_capacity(keep.len()); + let mut lsbs: Vec = Vec::with_capacity(keep.len()); + for &gid in keep { + if (gid as usize) < num_hm { + let o = gid as usize * 4; + advs.push(if o + 2 <= metrics.len() { ru16(metrics, o) } else { 0 }); + lsbs.push(if o + 4 <= metrics.len() { ri16(metrics, o + 2) } else { 0 }); + } else { + advs.push(last_adv); + let o = num_hm * 4 + (gid as usize - num_hm) * 2; + lsbs.push(if o + 2 <= metrics.len() { ri16(metrics, o) } else { 0 }); + } + } + // 尾部折叠:从尾向前找最长连续相同 advance 段(至少保留 1 个完整 longMetric) + let mut num_long: usize = advs.len(); + if advs.len() > 1 { + let tail_adv = advs[advs.len() - 1]; + let mut i = advs.len() - 1; + while i >= 1 { + if advs[i] != tail_adv { + num_long = i + 1; + break; + } + num_long = i; + i -= 1; + } + } + let mut out: Vec = Vec::with_capacity(num_long * 4 + (advs.len() - num_long) * 2); + for (i, &adv) in advs.iter().enumerate() { + if i < num_long { + out.extend_from_slice(&adv.to_be_bytes()); + out.extend_from_slice(&lsbs[i].to_be_bytes()); + } else { + out.extend_from_slice(&lsbs[i].to_be_bytes()); + } + } + MetricsResult { bytes: out, num_long: num_long as u32 } +} + +/// name 表白名单重建(语义对齐 otf-subset.ts buildSubsetName): +/// 保留 nameId 1/2/4/6/16/17,先扫 p3e1(Windows UTF-16)记录再补其他 platform, +/// 同 nameId 去重(先到先得),按收集序重建记录 + 字符串区。 +fn build_otf_subset_name(name: &[u8]) -> Result, SubsetError> { + let count = ru16(name, 2) as usize; + let string_off = ru16(name, 4) as usize; + struct Rec { + platform: u16, + encoding: u16, + lang: u16, + name_id: u16, + bytes: Vec, + } + let mut records: Vec = Vec::new(); + let mut seen: HashSet = HashSet::new(); + for pass in 0..2usize { + let mut i = 0usize; + while i < count { + let r = 6 + i * 12; + if r + 12 > name.len() { + break; + } + let platform = ru16(name, r); + let encoding = ru16(name, r + 2); + let lang = ru16(name, r + 4); + let name_id = ru16(name, r + 6); + let keep_id = name_id == 1 || name_id == 2 || name_id == 4 || name_id == 6 || name_id == 16 || name_id == 17; + if !keep_id { + i += 1; + continue; + } + let is_win = platform == 3 && encoding == 1; + if pass == 0 && !is_win { + i += 1; + continue; + } + if seen.contains(&name_id) { + i += 1; + continue; + } + let length = ru16(name, r + 8) as usize; + let offset = ru16(name, r + 10) as usize; + let s = string_off + offset; + if s + length > name.len() { + i += 1; + continue; + } + records.push(Rec { + platform, + encoding, + lang, + name_id, + bytes: name[s..s + length].to_vec(), + }); + seen.insert(name_id); + i += 1; + } + } + let header_size = 6 + records.len() * 12; + let str_size: usize = records.iter().map(|rec| rec.bytes.len()).sum(); + let mut out = vec![0u8; header_size + str_size]; + out[0..2].copy_from_slice(&0u16.to_be_bytes()); + out[2..4].copy_from_slice(&(records.len() as u16).to_be_bytes()); + out[4..6].copy_from_slice(&(header_size as u16).to_be_bytes()); + let mut str_acc: usize = 0; + for (i, rec) in records.iter().enumerate() { + let r = 6 + i * 12; + out[r..r + 2].copy_from_slice(&rec.platform.to_be_bytes()); + out[r + 2..r + 4].copy_from_slice(&rec.encoding.to_be_bytes()); + out[r + 4..r + 6].copy_from_slice(&rec.lang.to_be_bytes()); + out[r + 6..r + 8].copy_from_slice(&rec.name_id.to_be_bytes()); + out[r + 8..r + 10].copy_from_slice(&(rec.bytes.len() as u16).to_be_bytes()); + out[r + 10..r + 12].copy_from_slice(&(str_acc as u16).to_be_bytes()); + out[header_size + str_acc..header_size + str_acc + rec.bytes.len()].copy_from_slice(&rec.bytes); + str_acc += rec.bytes.len(); + } + Ok(out) +} + +/// 表 4 字节对齐 checksum(OpenType 规范:长度补齐到 4 字节后按大端 u32 累加,mod 2^32) +fn calc_table_checksum(bytes: &[u8]) -> u32 { + let mut sum: u32 = 0; + let quads = bytes.len() >> 2; + for i in 0..quads { + sum = sum.wrapping_add(ru32(bytes, i * 4)); + } + let tail = bytes.len() & 3; + if tail > 0 { + let mut last: u32 = 0; + for j in 0..tail { + last = (last << 8) | bytes[quads * 4 + j] as u32; + } + last <<= (4 - tail) * 8; + sum = sum.wrapping_add(last); + } + sum +} + +/// 封装 OTF sfnt('OTTO' 签名,语义对齐 otf-subset.ts assembleSfnt,skipCheckSum=false): +/// 表按 tag 升序,各表 4 字节对齐;目录写 checksum;head.checkSumAdjustment = +/// 0xB1B0AFBA - (目录区 sum + Σ 各表 checksum)。 +fn assemble_otto(tables: &mut [OtfOutTable]) -> Result, SubsetError> { + tables.sort_by(|x, y| x.tag.cmp(&y.tag)); + let n = tables.len(); + let entry_selector: u32 = 32 - (n as u32).leading_zeros() - 1; + let search_range: u32 = (1u32 << entry_selector) * 16; + let range_shift: u32 = n as u32 * 16 - search_range; + let dir_size = 12 + n * 16; + let data_total: usize = tables.iter().map(|t| (t.src.len() + 3) & !3usize).sum(); + + let mut out = vec![0u8; dir_size + data_total]; + out[0] = b'O'; + out[1] = b'T'; + out[2] = b'T'; + out[3] = b'O'; + out[4..6].copy_from_slice(&(n as u16).to_be_bytes()); + out[6..8].copy_from_slice(&(search_range as u16).to_be_bytes()); + out[8..10].copy_from_slice(&(entry_selector as u16).to_be_bytes()); + out[10..12].copy_from_slice(&(range_shift as u16).to_be_bytes()); + + let mut data_off: usize = dir_size; + let mut head_data_off: Option = None; + let mut tables_data_sum: u32 = 0; + for (i, t) in tables.iter().enumerate() { + let r = 12 + i * 16; + out[r..r + 4].copy_from_slice(&t.tag); + let cks = calc_table_checksum(&t.src); + tables_data_sum = tables_data_sum.wrapping_add(cks); + out[r + 4..r + 8].copy_from_slice(&cks.to_be_bytes()); + out[r + 8..r + 12].copy_from_slice(&(data_off as u32).to_be_bytes()); + out[r + 12..r + 16].copy_from_slice(&(t.src.len() as u32).to_be_bytes()); + out[data_off..data_off + t.src.len()].copy_from_slice(&t.src); + if &t.tag == b"head" { + head_data_off = Some(data_off); + } + data_off += (t.src.len() + 3) & !3usize; + } + if let Some(h) = head_data_off { + let mut dir_sum: u32 = 0; + let mut i = 0usize; + while i < dir_size { + dir_sum = dir_sum.wrapping_add(ru32(&out, i)); + i += 4; + } + let adjustment = 0xB1B0AFBAu32.wrapping_sub(dir_sum.wrapping_add(tables_data_sum)); + out[h + 8..h + 12].copy_from_slice(&adjustment.to_be_bytes()); + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 测试字体(仓库 font/ 目录真实字体;cargo test 工作目录 = rust-spike/) + const TEST_FONT: &str = "../font/方舟像素字体.ttf"; // 非 GSUB 路径,不依赖 gsub 桩 + + #[test] + fn parse_and_cmap_lookup() { + let data = std::fs::read(TEST_FONT).expect("read font"); + let f = Font::parse(data).expect("parse"); + assert!(f.num_glyphs > 0); + assert!(f.units_per_em >= 16 && f.units_per_em <= 16384); + // 中英码点均可查到 + for cp in ['字', '体', 'A', 'z'].iter() { + let gid = f.glyph_id(*cp as u32).expect("gid"); + assert!(gid > 0); + } + assert!(f.glyph_id(0x10FFFF).is_none()); // 民间区无映射 + } + + #[test] + fn collect_gids_sorted_with_notdef() { + let data = std::fs::read(TEST_FONT).expect("read font"); + let f = Font::parse(data).expect("parse"); + let gids = f.collect_gids("字体体测试fonts").expect("gids"); + assert_eq!(gids[0], 0); // gid 0 恒保留 + assert!(gids.windows(2).all(|w| w[0] < w[1])); // 升序去重 + // seed 序(不排序):0 + 码点首现序 + let seeds = f.seed_gids("字体体"); + assert_eq!(seeds[0], 0); + assert_eq!(seeds.len(), 3); // 重复「体」只计一次 + assert_eq!(seeds[1], f.glyph_id('字' as u32).unwrap()); + } + + #[test] + fn subset_output_roundtrips() { + let data = std::fs::read(TEST_FONT).expect("read font"); + let f = Font::parse(data).expect("parse"); + let out = subset(&f, "字体测试页").expect("subset"); + assert_eq!(out.len() % 4, 0); + // 产物本身可再解析,且 cmap 只含请求码点 + let f2 = Font::parse(out).expect("reparse"); + for ch in "字体测试页".chars() { + assert!(f2.glyph_id(ch as u32).is_some(), "missing {ch}"); + } + assert!(f2.glyph_id('A' as u32).is_none()); // 未请求码点不保留 + // loca 单调不减且终止于 glyf 末尾(按 indexToLocFormat 读 short/long) + let loca = f2.find_table(b"loca").unwrap(); + let glyf_len = f2.find_table(b"glyf").unwrap().len() as u32; + let n = f2.num_glyphs as usize; + let mut prev: u32 = 0; + for i in 0..=n { + let v = if f2.index_to_loc_format == 0 { + ru16(loca, i * 2) as u32 * 2 + } else { + ru32(loca, i * 4) + }; + assert!(v >= prev, "loca not monotonic at {i}"); + prev = v; + } + assert_eq!(prev, glyf_len); + } + + #[test] + fn cmap4_delta_roundtrip_on_synthetic() { + // 合成 pairs:含 gid-cp 差超 ±32767 的段(writeCmap4 截断合并语义)。 + // 产物是 cmap 表字节而非 sfnt,用 parse_cmap4 直接解码子表(header 12B 后即 format4) + let pairs = [ + CpPair { cp: 0x4E2D, gid: 3 }, + CpPair { cp: 0x4E2E, gid: 4 }, + CpPair { cp: 65288, gid: 11 }, // 差 -65277,u16 截断后仍命中 + ]; + let mut out = Vec::new(); + write_cmap4(&mut out, &pairs).expect("cmap4"); + let mut cmap: HashMap = HashMap::new(); + parse_cmap4(&out[12..], 1000, &mut cmap); + assert_eq!(cmap.get(&0x4E2D), Some(&3)); + assert_eq!(cmap.get(&0x4E2E), Some(&4)); + assert_eq!(cmap.get(&65288), Some(&11)); + assert!(cmap.get(&0x4E2F).is_none()); + } + + #[test] + fn cmap12_astral_roundtrip() { + // astral 码点触发 format12 双子表:format4 @20,format12 @20+sub4.len() + let pairs = [ + CpPair { cp: 0x41, gid: 1 }, + CpPair { cp: 0x20000, gid: 2 }, + CpPair { cp: 0x20001, gid: 3 }, + ]; + let mut out = Vec::new(); + write_cmap4(&mut out, &pairs).expect("cmap"); + // 子表数量 2,format12 偏移取自记录 + assert_eq!(ru16(&out, 2), 2); + let off12 = ru32(&out, 16) as usize; + let mut cmap: HashMap = HashMap::new(); + parse_cmap12(&out[off12..], 1000, &mut cmap); + assert_eq!(cmap.get(&0x41), Some(&1)); + assert_eq!(cmap.get(&0x20000), Some(&2)); + assert_eq!(cmap.get(&0x20001), Some(&3)); + } + + #[test] + fn anchor_injection_short_cjk_only() { + // 短中文文本注入 32 锚定字;长文本/纯 ASCII 不注入 + assert!(maybe_inject_anchors("字体").is_some()); + assert!(maybe_inject_anchors("abc").is_none()); + // ≥32 个唯一码点不注入(用 ANCHOR 自身 32 个 + 2 个不同字) + let long = format!("{ANCHOR_CODEPOINTS}字体"); + assert!(maybe_inject_anchors(&long).is_none()); + let inj = maybe_inject_anchors("字").unwrap(); + assert!(inj.starts_with('字')); + assert_eq!(unique_cp_count(&inj), 33); + } + + #[test] + fn otf_rejected_in_ttf_pipeline() { + // 非真字体签名 → NotTtf(parse 侧);OTF 走 subset_otf 需要 CFF 桩,此处只测 parse + let bad = Font::parse(b"MZ\x00\x00not a font at all........".to_vec()); + assert!(matches!(bad, Err(ParseError::NotTtf))); + } +} diff --git a/rust-spike/src/woff2.rs b/rust-spike/src/woff2.rs new file mode 100644 index 0000000..b3f5bfa --- /dev/null +++ b/rust-spike/src/woff2.rs @@ -0,0 +1,1025 @@ +//! WOFF2 编码器:bug-for-bug 移植自 zig-spike/src/woff2.zig(其源自 vendor/fonteditor-core/woff2/woff2-encode.ts) +//! 压缩:brotli crate(纯 Rust 实现)。 +//! 已知差异:Rust brotli 与 Zig 静态链接的 C libbrotli(google/brotli v1.2.0)在相同参数 +//! (quality=2, lgwin=22, sizeHint=未压缩表数据长度)下压缩流不逐字节一致——两实现的 +//! Huffman/匹配决策不同,Rust 输出稳定略小(实测 ~0.1%);解码等价性由 fixture 对拍 +//! 测试保证(两侧 woff2 解码回的 TTF 逐字节一致,见文件尾 #[test] 与报告)。 +//! 参考: https://www.w3.org/TR/WOFF2/ +use brotli::enc::BrotliEncoderParams; + +/// brotli 质量级对齐 TS 侧默认:quality 2(q2 比 q3 省 8% 时间、体积仅 +0.09%) +const BROTLI_QUALITY: i32 = 2; +/// 窗口大小对齐 node zlib 默认(BROTLI_DEFAULT_WINDOW) +const BROTLI_LGWIN: i32 = 22; + +/// Known Table Tags(与 TS KNOWN_TAGS 同序;"VORG " 的尾空格是 TS 字符串形式残留, +/// tag 比较只用前 4 字节,语义等价) +const KNOWN_TAGS: [[u8; 4]; 50] = [ + *b"cmap", *b"head", *b"hhea", *b"hmtx", *b"maxp", *b"name", *b"OS/2", *b"post", + *b"cvt ", *b"fpgm", *b"glyf", *b"loca", *b"prep", *b"CFF ", *b"VORG", *b"EBDT", + *b"EBLC", *b"EBSC", *b"CBDT", *b"CBLC", *b"COLR", *b"CPAL", *b"SVG ", *b"sbix", + *b"acnt", *b"avar", *b"bdat", *b"bloc", *b"bsln", *b"cvar", *b"fdsc", *b"feat", + *b"fmtx", *b"fvar", *b"gvar", *b"gdef", *b"hsty", *b"jstf", *b"lcar", *b"mort", + *b"morx", *b"opbd", *b"prop", *b"trak", *b"Zapf", *b"Silf", *b"Glat", *b"Gloc", + *b"Feat", *b"Sill", +]; + +/// 从 4 字节 tag 获取 Known Table Tag 索引;不在表内返回 63(自定义 tag) +fn tag_index(tag: &[u8; 4]) -> usize { + for (i, t) in KNOWN_TAGS.iter().enumerate() { + if t == tag { + return i; + } + } + 63 +} + +/// UIntBase128 编码字节数 +fn size_u_int_base128(value: u32) -> usize { + if value < 0x80 { + return 1; + } + if value < 0x4000 { + return 2; + } + if value < 0x200000 { + return 3; + } + if value < 0x10000000 { + return 4; + } + 5 +} + +/// 编码 UIntBase128 到 buf[offset..](大端序:高位 7 位组在前,除末字节外均置续位 0x80) +fn encode_u_int_base128(value: u32, buf: &mut [u8], offset: usize) -> usize { + let mut tmp = [0u8; 5]; + let mut n = 0; + let mut v = value; + tmp[n] = (v & 0x7F) as u8; + n += 1; + v >>= 7; + while v != 0 { + tmp[n] = ((v & 0x7F) | 0x80) as u8; + n += 1; + v >>= 7; + } + for (i, item) in tmp[..n].iter().rev().enumerate() { + buf[offset + i] = *item; + } + n +} + +/// 255UInt16 编码字节数 +fn size_255_u_int16(value: u16) -> usize { + if value <= 252 { + return 1; + } + if value <= 762 { + return 2; + } + 3 +} + +/// 编码 255UInt16 追加到 out,返回写入字节数(Zig 版保留函数,当前编码主路径未使用) +#[allow(dead_code)] // 对译保留:Zig append255UInt16 +fn append_255_u_int16(out: &mut Vec, value: u16) -> usize { + if value < 253 { + out.push(value as u8); + return 1; + } + if value < 506 { + out.extend_from_slice(&[255, (value - 253) as u8]); + return 2; + } + if value < 762 { + out.extend_from_slice(&[254, (value - 506) as u8]); + return 2; + } + out.extend_from_slice(&[253, (value >> 8) as u8, (value & 0xFF) as u8]); + 3 +} + +/// 编码 255UInt16 到定长 3 字节缓冲(写入变长区间) +fn write_255_u_int16(buf: &mut [u8], offset: usize, value: u16) -> usize { + if value < 253 { + buf[offset] = value as u8; + return 1; + } + if value < 506 { + buf[offset] = 255; + buf[offset + 1] = (value - 253) as u8; + return 2; + } + if value < 762 { + buf[offset] = 254; + buf[offset + 1] = (value - 506) as u8; + return 2; + } + buf[offset] = 253; + buf[offset + 1] = (value >> 8) as u8; + buf[offset + 2] = (value & 0xFF) as u8; + 3 +} + +fn read_u16(data: &[u8], off: usize) -> u16 { + u16::from_be_bytes([data[off], data[off + 1]]) +} + +fn read_i16(data: &[u8], off: usize) -> i16 { + i16::from_be_bytes([data[off], data[off + 1]]) +} + +fn read_u32(data: &[u8], off: usize) -> u32 { + u32::from_be_bytes([data[off], data[off + 1], data[off + 2], data[off + 3]]) +} + +fn write_u16(buf: &mut [u8], off: usize, v: u16) { + buf[off..off + 2].copy_from_slice(&v.to_be_bytes()); +} + +fn write_u32(buf: &mut [u8], off: usize, v: u32) { + buf[off..off + 4].copy_from_slice(&v.to_be_bytes()); +} + +/// 复合 glyph 元数据(Pass 2 写 bboxStream 用) +struct CompositeInfo { + x_min: i16, + y_min: i16, + x_max: i16, + y_max: i16, + #[allow(dead_code)] // bug-for-bug 对译保留:原始字形/指令段位置(Zig 版同名字段,防御性记录未消费) + raw_offset: usize, + #[allow(dead_code)] // 同 raw_offset + raw_length: usize, + #[allow(dead_code)] // 同 raw_offset + instr_offset: usize, + #[allow(dead_code)] // 同 raw_offset + instr_length: usize, +} + +/// 简单 glyph 元数据(Pass 2 写 nContour/nPoints 用) +struct SimpleInfo { + number_of_contours: i16, + /// 各轮廓点数 delta(255UInt16 编码) + n_points_deltas: Vec, +} + +enum GlyphInfo { + Empty, + Composite(CompositeInfo), + Simple(SimpleInfo), +} + +/// glyf/loca 变换结果 +struct TransformResult { + transformed_glyf: Vec, + loca_orig_length: u32, +} + +fn read_loca_offsets(loca_data: &[u8], index_format: u16, num_glyphs: usize) -> Vec { + let mut offsets = vec![0u32; num_glyphs + 1]; + if index_format == 0 { + for (i, off) in offsets.iter_mut().enumerate() { + *off = read_u16(loca_data, i * 2) as u32 * 2; + } + } else { + for (i, off) in offsets.iter_mut().enumerate() { + *off = read_u32(loca_data, i * 4); + } + } + offsets +} + +/// 对 glyf + loca 执行 WOFF2 变换(TS transformGlyfAndLoca 移植) +fn transform_glyf_and_loca( + glyf_data: &[u8], + loca_data: &[u8], + index_format: u16, + num_glyphs: usize, +) -> TransformResult { + let offsets = read_loca_offsets(loca_data, index_format, num_glyphs); + + let xshort_flag: u8 = 2; + let xsame_flag: u8 = 16; + let yshort_flag: u8 = 4; + let ysame_flag: u8 = 32; + let repeat_flag: u8 = 8; + let overlap_flag: u8 = 64; + + let mut flag_accum: Vec = Vec::new(); + let mut glyph_accum: Vec = Vec::new(); + let mut instr_accum: Vec = Vec::new(); + + let mut total_n_points_size: usize = 0; + let mut bbox_stream_size: usize = 0; + let mut has_overlap_bitmap = false; + + let bbox_bitmap_size: usize = ((num_glyphs + 31) >> 5) << 2; + let mut bbox_bitmap = vec![0u8; bbox_bitmap_size]; + let mut overlap_bitmap = vec![0u8; bbox_bitmap_size]; + + let mut glyph_infos: Vec = Vec::with_capacity(num_glyphs); + + for gi in 0..num_glyphs { + let glyph_start = offsets[gi] as usize; + let glyph_end = offsets[gi + 1] as usize; + + if glyph_start == glyph_end { + glyph_infos.push(GlyphInfo::Empty); + continue; + } + + let number_of_contours = read_i16(glyf_data, glyph_start); + + if number_of_contours < 0 { + // 复合 glyph:bbox 显式存 bboxStream(raw 组件数据剥离 glyph 头,解码端无法重建) + let x_min = read_i16(glyf_data, glyph_start + 2); + let y_min = read_i16(glyf_data, glyph_start + 4); + let x_max = read_i16(glyf_data, glyph_start + 6); + let y_max = read_i16(glyf_data, glyph_start + 8); + let mut comp_off: usize = glyph_start + 10; + let mut have_instructions = false; + let mut instr_length: usize = 0; + let mut instr_offset: usize = 0; + + let more_components: u16 = 0x0020; + let we_have_instructions: u16 = 0x0100; + while comp_off < glyph_end { + let comp_flags = read_u16(glyf_data, comp_off); + comp_off += 2; + comp_off += 2; // glyphIndex + + comp_off += if comp_flags & 0x0001 != 0 { 4 } else { 2 }; + if comp_flags & 0x0008 != 0 { + comp_off += 2; + } else if comp_flags & 0x0040 != 0 { + comp_off += 4; + } else if comp_flags & 0x0080 != 0 { + comp_off += 8; + } + + if comp_off > glyph_end { + comp_off = glyph_end; + have_instructions = false; + break; + } + if comp_flags & more_components == 0 { + have_instructions = comp_flags & we_have_instructions != 0; + break; + } + } + + let component_data_end = comp_off; + + if have_instructions && comp_off + 2 <= glyph_end { + instr_length = read_u16(glyf_data, comp_off) as usize; + comp_off += 2; + if instr_length > 0 && comp_off + instr_length <= glyph_end { + instr_offset = comp_off; + } else { + instr_length = 0; + } + } + + let raw_offset = glyph_start + 10; + let raw_length = component_data_end - glyph_start - 10; + + glyph_infos.push(GlyphInfo::Composite(CompositeInfo { + x_min, + y_min, + x_max, + y_max, + raw_offset, + raw_length, + instr_offset, + instr_length, + })); + + bbox_bitmap[gi >> 3] |= 0x80u8 >> (gi & 7); + bbox_stream_size += 8; + + glyph_accum.extend_from_slice(&glyf_data[raw_offset..raw_offset + raw_length]); + + if instr_length > 0 { + instr_accum.extend_from_slice(&glyf_data[instr_offset..instr_offset + instr_length]); + let mut enc = [0u8; 3]; + let n = write_255_u_int16(&mut enc, 0, instr_length as u16); + glyph_accum.extend_from_slice(&enc[..n]); + } + continue; + } + + // 简单 glyph + let mut data_off: usize = glyph_start + 10; + + let mut n_points_deltas = vec![0u16; number_of_contours as usize]; + let mut n_points_bytes: usize = 0; + let mut prev_end: i32 = -1; + let last_end_pt: i32; + for delta in n_points_deltas.iter_mut() { + let end_pt: i32 = read_u16(glyf_data, data_off) as i32; + data_off += 2; + // 有损截断对齐 Zig @intCast:delta = end_pt - prev_end(prev_end 初始 -1), + // 正常字体 endPtOfContours 单调不减且 ≤ 65535,delta ∈ [0, 65536], + // 异常畸形字体的回绕行为与 Zig release 构建一致 + *delta = (end_pt - prev_end) as u16; + n_points_bytes += size_255_u_int16(*delta); + prev_end = end_pt; + } + last_end_pt = prev_end; + total_n_points_size += n_points_bytes; + + let instruction_length: usize = read_u16(glyf_data, data_off) as usize; + data_off += 2; + let instr_offset = data_off; + data_off += instruction_length; + + if instruction_length > 0 { + instr_accum.extend_from_slice(&glyf_data[instr_offset..instr_offset + instruction_length]); + } + + let num_points: usize = if number_of_contours > 0 { (last_end_pt + 1) as usize } else { 0 }; + + // 原始 flags 解码(REPEAT 展开)写入 flag_accum + let flag_write_base = flag_accum.len(); + flag_accum.resize(flag_write_base + num_points, 0); + let mut has_overlap = false; + { + let mut fi: usize = 0; + while fi < num_points { + let flag = glyf_data[data_off]; + data_off += 1; + if flag & overlap_flag != 0 { + has_overlap = true; + } + flag_accum[flag_write_base + fi] = flag; + fi += 1; + if flag & repeat_flag != 0 && fi < num_points { + let repeat = glyf_data[data_off]; + data_off += 1; + let count: usize = std::cmp::min(repeat as usize, num_points - fi); + flag_accum[flag_write_base + fi..flag_write_base + fi + count].fill(flag); + fi += count; + } + } + } + + if number_of_contours > 0 && has_overlap { + has_overlap_bitmap = true; + overlap_bitmap[gi >> 3] |= 0x80u8 >> (gi & 7); + } + + // x 解码直接存 delta(TTF xCoordinates 本就是相对前点的 delta) + let mut x_coords = vec![0i32; num_points]; + for (xi, xc) in x_coords.iter_mut().enumerate() { + let f = flag_accum[flag_write_base + xi]; + if f & xshort_flag != 0 { + let b: i32 = glyf_data[data_off] as i32; + data_off += 1; + *xc = if f & xsame_flag != 0 { b } else { -b }; + } else if f & xsame_flag == 0 { + let dx: i32 = read_i16(glyf_data, data_off) as i32; + data_off += 2; + *xc = dx; + } else { + *xc = 0; + } + } + + if number_of_contours > 0 { + let gs_base = glyph_accum.len(); + // 每点最多 4 数据字节,预扩容(写指针直写,避免逐点 append) + glyph_accum.resize(gs_base + num_points * 4, 0); + let gs = &mut glyph_accum[gs_base..]; + let mut gsbi: usize = 0; + for (yi, item) in flag_accum[flag_write_base..flag_write_base + num_points] + .iter_mut() + .enumerate() + { + let f = *item; + let dy: i32; + if f & yshort_flag != 0 { + let b: i32 = glyf_data[data_off] as i32; + data_off += 1; + dy = if f & ysame_flag != 0 { b } else { -b }; + } else if f & ysame_flag == 0 { + dy = read_i16(glyf_data, data_off) as i32; + data_off += 2; + } else { + dy = 0; + } + + let dx = x_coords[yi]; + let curve_bit: u16 = (((f & 1) ^ 1) as u16) << 7; + // 无分支 abs + 符号位(dx/dy 为 i32,>>31 负时 -1) + let dx_sgn = dx >> 31; + let dy_sgn = dy >> 31; + let abs_dx = (dx ^ dx_sgn) - dx_sgn; + let abs_dy = (dy ^ dy_sgn) - dy_sgn; + let x_sign_bit: u16 = (dx_sgn + 1) as u16; + let y_sign_bit: u16 = (dy_sgn + 1) as u16; + let wpos = gsbi; + let flag: u16; + let adv: usize; + if dx == 0 && abs_dy < 1280 { + gs[wpos] = abs_dy as u32 as u8; + flag = curve_bit + (((abs_dy as u32 & 0xF00) as u16) >> 7) + y_sign_bit; + adv = 1; + } else if dy == 0 && abs_dx < 1280 { + gs[wpos] = abs_dx as u32 as u8; + flag = curve_bit + 10 + (((abs_dx as u32 & 0xF00) as u16) >> 7) + x_sign_bit; + adv = 1; + } else if abs_dx < 65 && abs_dy < 65 { + let ax: u32 = abs_dx as u32 - 1; + let ay: u32 = abs_dy as u32 - 1; + gs[wpos] = (((ax & 0xF) << 4) | (ay & 0xF)) as u8; + flag = curve_bit + 20 + ((ax & 0x30) as u16) + (((ay & 0x30) as u16) >> 2) + x_sign_bit + 2 * y_sign_bit; + adv = 1; + } else if abs_dx < 769 && abs_dy < 769 { + let ax: u32 = abs_dx as u32 - 1; + let ay: u32 = abs_dy as u32 - 1; + gs[wpos] = (ax & 0xFF) as u8; + gs[wpos + 1] = (ay & 0xFF) as u8; + flag = curve_bit + 84 + 12 * (((ax & 0x300) as u16) >> 8) + (((ay & 0x300) as u16) >> 6) + x_sign_bit + 2 * y_sign_bit; + adv = 2; + } else if abs_dx < 4096 && abs_dy < 4096 { + gs[wpos] = (abs_dx as u32 >> 4) as u8; + gs[wpos + 1] = (((abs_dx as u32 & 0xF) << 4) | (abs_dy as u32 >> 8)) as u8; + gs[wpos + 2] = (abs_dy as u32) as u8; + flag = curve_bit + 120 + x_sign_bit + 2 * y_sign_bit; + adv = 3; + } else { + gs[wpos] = (abs_dx as u32 >> 8) as u8; + gs[wpos + 1] = (abs_dx as u32) as u8; + gs[wpos + 2] = (abs_dy as u32 >> 8) as u8; + gs[wpos + 3] = (abs_dy as u32) as u8; + flag = curve_bit + 124 + x_sign_bit + 2 * y_sign_bit; + adv = 4; + } + // triplet flag 回写 flag_accum(flagStream 存 triplet flag) + *item = flag as u8; + gsbi += adv; + } + glyph_accum.truncate(gs_base + gsbi); + + let mut enc = [0u8; 3]; + let n = write_255_u_int16(&mut enc, 0, instruction_length as u16); + glyph_accum.extend_from_slice(&enc[..n]); + } else { + // numberOfContours === 0 的空字形:仍需消费 yCoord 字节以推进 dataOff(保持 TS 原语义) + // (num_points 此时恒为 0,循环实际不执行,忠实保留 TS 原结构) + for yi0 in 0..num_points { + let f = flag_accum[flag_write_base + yi0]; + if f & yshort_flag != 0 { + data_off += 1; + } else if f & ysame_flag == 0 { + data_off += 2; + } + } + // dataOff 此后不再消费(TS 原语义的推进保持),显式读取抑制 dead-store 警告 + let _ = data_off; + } + + glyph_infos.push(GlyphInfo::Simple(SimpleInfo { + number_of_contours, + n_points_deltas, + })); + } + + let n_contour_stream_size = num_glyphs * 2; + let header_size = 36; + let flag_stream_size = flag_accum.len(); + let instruction_stream_size = instr_accum.len(); + let overlap_bitmap_size: usize = if has_overlap_bitmap { bbox_bitmap_size } else { 0 }; + let glyph_stream_size = glyph_accum.len(); + let total_size = header_size + + n_contour_stream_size + + total_n_points_size + + flag_stream_size + + glyph_stream_size + + bbox_bitmap_size + + bbox_stream_size + + instruction_stream_size + + overlap_bitmap_size; + + // TS 的 new Uint8Array 零填充;空字形 nContour 槽等位置依赖跳写后的零值 + let mut result = vec![0u8; total_size]; + + // Header + let mut pos: usize = 0; + write_u16(&mut result, pos, 0); + pos += 2; + write_u16(&mut result, pos, if has_overlap_bitmap { 1 } else { 0 }); + pos += 2; + write_u16(&mut result, pos, num_glyphs as u16); + pos += 2; + write_u16(&mut result, pos, index_format); + pos += 2; + write_u32(&mut result, pos, n_contour_stream_size as u32); + pos += 4; + write_u32(&mut result, pos, total_n_points_size as u32); + pos += 4; + write_u32(&mut result, pos, flag_stream_size as u32); + pos += 4; + write_u32(&mut result, pos, glyph_stream_size as u32); + pos += 4; + write_u32(&mut result, pos, 0); // compositeStreamSize 占位(TS 写 0,组件数据在 glyphStream) + pos += 4; + write_u32(&mut result, pos, (bbox_bitmap_size + bbox_stream_size) as u32); + pos += 4; + write_u32(&mut result, pos, instruction_stream_size as u32); + pos += 4; + + let n_contour_end = pos + n_contour_stream_size; + let mut n_contour_pos = pos; + let mut n_points_pos = n_contour_end; + pos = n_contour_end + total_n_points_size; + + let flag_stream_start = pos; + pos += flag_stream_size; + let glyph_stream_start = pos; + pos += glyph_stream_size; + let bbox_bitmap_start = pos; + pos += bbox_bitmap_size; + // pos 现指向 bboxStream 起点(bitmap 之后) + let mut bbox_pos = pos; + + for g in &glyph_infos { + match g { + GlyphInfo::Empty => n_contour_pos += 2, + GlyphInfo::Composite(ci) => { + write_u16(&mut result, n_contour_pos, 0xFFFF); + n_contour_pos += 2; + write_u16(&mut result, bbox_pos, ci.x_min as u16); + write_u16(&mut result, bbox_pos + 2, ci.y_min as u16); + write_u16(&mut result, bbox_pos + 4, ci.x_max as u16); + write_u16(&mut result, bbox_pos + 6, ci.y_max as u16); + bbox_pos += 8; + } + GlyphInfo::Simple(si) => { + write_u16(&mut result, n_contour_pos, si.number_of_contours as u16); + n_contour_pos += 2; + if si.number_of_contours == 0 { + continue; + } + for d in &si.n_points_deltas { + n_points_pos += write_255_u_int16(&mut result, n_points_pos, *d); + } + } + } + } + + result[flag_stream_start..flag_stream_start + flag_stream_size].copy_from_slice(&flag_accum); + result[glyph_stream_start..glyph_stream_start + glyph_stream_size].copy_from_slice(&glyph_accum); + if instruction_stream_size > 0 { + // pos 已含 bitmap_size,只补 bboxStream + let s = pos + bbox_stream_size; + result[s..s + instruction_stream_size].copy_from_slice(&instr_accum); + } + + result[bbox_bitmap_start..bbox_bitmap_start + bbox_bitmap_size].copy_from_slice(&bbox_bitmap); + + if has_overlap_bitmap { + let s = pos + bbox_stream_size + instruction_stream_size; + result[s..s + overlap_bitmap_size].copy_from_slice(&overlap_bitmap); + } + + let loca_orig_length: u32 = if index_format == 0 { + ((num_glyphs + 1) * 2) as u32 + } else { + ((num_glyphs + 1) * 4) as u32 + }; + + TransformResult { + transformed_glyf: result, + loca_orig_length, + } +} + +/// sfnt 表目录项(解析自 TTF) +#[derive(Clone)] +struct SfntTable { + tag: [u8; 4], + offset: u32, + length: u32, + tag_index: usize, +} + +/// WOFF2 Table Directory entry +struct DirEntry<'a> { + tag: [u8; 4], + tag_index: usize, + /// flags 字节(tagIndex | 变换版本位;glyf/loca 变换=版本0 不置 0x40) + flags: u8, + orig_length: u32, + /// 目录序列化追加 transformLength 字段(loca 变换=0/glyf 变换=变换后长度) + has_transform: bool, + /// 拼接进压缩数据的字节(非变换表=原始字节;空 loca 为空) + data: &'a [u8], + is_head: bool, +} + +const WOFF2_SIGNATURE: u32 = 0x774F4632; +const WOFF2_HEADER_SIZE: usize = 48; + +/// 计算单个 Table Directory entry 的序列化字节数 +fn entry_size(tag_index: usize, orig_length: u32, has_transform: bool, transform_length: u32) -> usize { + 1 + + (if tag_index == 63 { 4 } else { 0 }) + + size_u_int_base128(orig_length) + + (if has_transform { size_u_int_base128(transform_length) } else { 0 }) +} + +/// WOFF2 编码错误(对译 Zig EncodeError;Rust 侧分配失败直接 abort,无 OutOfMemory; +/// brotli 参数经由 struct 字段设置不会失败,无 BrotliInit/BrotliParam) +#[derive(Debug)] +pub enum EncodeError { + /// data 不是合法 sfnt(长度不足或表目录越界) + NotSfnt, + /// 表 offset+length 超出 buffer + BadTable, + /// brotli 压缩失败 + BrotliCompress, +} + +/// brotli 压缩(quality=2 + sizeHint 对齐 TS brotliCompressSync params) +fn brotli_compress(input: &[u8], size_hint: usize) -> Result, EncodeError> { + let mut params = BrotliEncoderParams::default(); + params.quality = BROTLI_QUALITY; + params.lgwin = BROTLI_LGWIN; + params.size_hint = size_hint; + let mut out = Vec::new(); + let mut reader = input; + brotli::BrotliCompress(&mut reader, &mut out, &mut params).map_err(|_| EncodeError::BrotliCompress)?; + Ok(out) +} + +/// 将 sfnt(TTF/OTF)buffer 编码为 WOFF2 buffer(TS encodeTTFToWOFF2 移植) +pub fn encode_ttf_to_woff2(data: &[u8]) -> Result, EncodeError> { + if data.len() < 12 { + return Err(EncodeError::NotSfnt); + } + let flavor = read_u32(data, 0); + let num_tables: usize = read_u16(data, 4) as usize; + + // 解析 Table Directory + let mut tables = Vec::with_capacity(num_tables); + for i in 0..num_tables { + let off = 12 + i * 16; + if off + 16 > data.len() { + return Err(EncodeError::NotSfnt); + } + tables.push(SfntTable { + tag: data[off..off + 4].try_into().unwrap(), + offset: read_u32(data, off + 8), + length: read_u32(data, off + 12), + tag_index: tag_index(&data[off..off + 4].try_into().unwrap()), + }); + } + + // 移除 DSIG(保序过滤,语义对齐 Zig write_idx 压缩) + tables.retain(|t| t.tag != *b"DSIG"); + // 稳定排序(对齐 Zig std.mem.sort = std.sort.block 稳定序) + tables.sort_by(|a, b| a.tag_index.cmp(&b.tag_index).then_with(|| a.tag.cmp(&b.tag))); + let filtered = &tables; + + // 查找关键表 + let mut index_to_loc_format: u16 = 0; + let mut num_glyphs: usize = 0; + let mut glyf_table: Option = None; + let mut loca_table: Option = None; + for t in filtered { + if t.tag == *b"head" && t.offset as usize + 52 <= data.len() { + index_to_loc_format = read_u16(data, t.offset as usize + 50); + } + if t.tag == *b"maxp" && t.offset as usize + 6 <= data.len() { + num_glyphs = read_u16(data, t.offset as usize + 4) as usize; + } + if t.tag == *b"glyf" { + glyf_table = Some(t.clone()); + } + if t.tag == *b"loca" { + loca_table = Some(t.clone()); + } + } + + // glyf + loca 变换(任一缺失则整体不变换) + let glyf_transformed: Option = if glyf_table.is_some() && loca_table.is_some() { + let gt = glyf_table.as_ref().unwrap(); + let lt = loca_table.as_ref().unwrap(); + if gt.offset as usize + gt.length as usize > data.len() || lt.offset as usize + lt.length as usize > data.len() { + return Err(EncodeError::BadTable); + } + Some(transform_glyf_and_loca( + &data[gt.offset as usize..gt.offset as usize + gt.length as usize], + &data[lt.offset as usize..lt.offset as usize + lt.length as usize], + index_to_loc_format, + num_glyphs, + )) + } else { + None + }; + + // 构建 Table Directory entries + let mut dir_entries: Vec = Vec::new(); + let mut total_dir_size: usize = 0; + + for t in filtered { + if t.tag == *b"loca" { + if glyf_transformed.is_none() { + // 无 glyf(如 CFF/OTF):loca 不会单独存在,理论不达;防御性透传 + let d = &data[t.offset as usize..t.offset as usize + t.length as usize]; + dir_entries.push(DirEntry { + tag: t.tag, + tag_index: t.tag_index, + flags: t.tag_index as u8 | 0x40, + orig_length: t.length, + has_transform: false, + data: d, + is_head: false, + }); + total_dir_size += entry_size(t.tag_index, t.length, false, t.length); + continue; + } + let orig_length = glyf_transformed.as_ref().unwrap().loca_orig_length; + dir_entries.push(DirEntry { + tag: t.tag, + tag_index: t.tag_index, + flags: t.tag_index as u8, + orig_length, + has_transform: true, + data: &[], + is_head: false, + }); + total_dir_size += entry_size(t.tag_index, orig_length, true, 0); + continue; + } + + if t.tag == *b"glyf" && glyf_transformed.is_some() { + let tl = glyf_transformed.as_ref().unwrap().transformed_glyf.len() as u32; + dir_entries.push(DirEntry { + tag: t.tag, + tag_index: t.tag_index, + flags: t.tag_index as u8, + orig_length: t.length, + has_transform: true, + data: &glyf_transformed.as_ref().unwrap().transformed_glyf, + is_head: false, + }); + total_dir_size += entry_size(t.tag_index, t.length, true, tl); + continue; + } + + if t.offset as usize + t.length as usize > data.len() { + return Err(EncodeError::BadTable); + } + let table_data = &data[t.offset as usize..t.offset as usize + t.length as usize]; + dir_entries.push(DirEntry { + tag: t.tag, + tag_index: t.tag_index, + flags: t.tag_index as u8, + orig_length: t.length, + has_transform: false, + data: table_data, + is_head: t.tag == *b"head", + }); + total_dir_size += entry_size(t.tag_index, t.length, false, t.length); + } + + // totalSfntSize(解码端重建 TTF 所需字节数) + let mut total_sfnt_size: usize = 12 + filtered.len() * 16; + for t in filtered { + total_sfnt_size += t.length as usize + ((4 - (t.length as usize & 3)) & 3); + } + + // 拼接表数据(head patch:checkSumAdjustment 清零 + flags 置 bit11) + let mut total_table_data_size: usize = 0; + for e in &dir_entries { + total_table_data_size += e.data.len(); + } + let mut uncompressed_data = vec![0u8; total_table_data_size]; + let mut data_pos: usize = 0; + for e in &dir_entries { + if !e.data.is_empty() { + uncompressed_data[data_pos..data_pos + e.data.len()].copy_from_slice(e.data); + if e.is_head && e.data.len() >= 46 { + let base = data_pos; + uncompressed_data[base + 8..base + 12].fill(0); + let head_flags = ((uncompressed_data[base + 44] as u16) << 8) | uncompressed_data[base + 45] as u16; + let new_flags = head_flags | (1 << 11); + uncompressed_data[base + 44] = (new_flags >> 8) as u8; + uncompressed_data[base + 45] = (new_flags & 0xFF) as u8; + } + data_pos += e.data.len(); + } + } + + let compressed_data = brotli_compress(&uncompressed_data, total_table_data_size)?; + + // 组装 WOFF2(Round4 padding 预留) + let raw_length = WOFF2_HEADER_SIZE + total_dir_size + compressed_data.len(); + let padded_length = (raw_length + 3) & !3; + // 长度 < 4GB(u32 上限)在字体场景恒成立,截断语义对齐 Zig @intCast + let mut woff2 = vec![0u8; padded_length]; + + // Header + write_u32(&mut woff2, 0, WOFF2_SIGNATURE); + write_u32(&mut woff2, 4, flavor); + write_u32(&mut woff2, 8, padded_length as u32); + write_u16(&mut woff2, 12, dir_entries.len() as u16); + write_u16(&mut woff2, 14, 0); + write_u32(&mut woff2, 16, total_sfnt_size as u32); + write_u32(&mut woff2, 20, compressed_data.len() as u32); + write_u16(&mut woff2, 24, 1); + write_u16(&mut woff2, 26, 0); + + // Table Directory + let mut dir_pos: usize = WOFF2_HEADER_SIZE; + for e in &dir_entries { + woff2[dir_pos] = e.flags; + dir_pos += 1; + if e.tag_index == 63 { + woff2[dir_pos..dir_pos + 4].copy_from_slice(&e.tag); + dir_pos += 4; + } + dir_pos += encode_u_int_base128(e.orig_length, &mut woff2, dir_pos); + if e.has_transform { + let tl: u32 = if e.tag == *b"glyf" { + e.data.len() as u32 + } else { + 0 + }; + dir_pos += encode_u_int_base128(tl, &mut woff2, dir_pos); + } + } + + // 压缩数据 + woff2[dir_pos..dir_pos + compressed_data.len()].copy_from_slice(&compressed_data); + + Ok(woff2) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// fixture 获取方式(8090 端口 zig-spike 服务,同 text 的 ttf/woff2 互为 oracle): + /// curl -s -o /tmp/fix1.ttf 'http://127.0.0.1:8090/api?font=鸿蒙黑体.ttf&text=中文字体测试ABCabc123&outType=ttf' + /// curl -s -o /tmp/fix1.woff2 'http://127.0.0.1:8090/api?font=鸿蒙黑体.ttf&text=中文字体测试ABCabc123&outType=woff2' + /// (fix2 = 令东齐伋复刻体.ttf,text=永和九年岁在癸丑暮春之初会于会稽山阴之兰亭The quick brown fox 0123456789) + /// (fix3 = 思源黑体.ttf,text=永和九年岁在癸丑ABCabc) + /// fixture 不在时测试空转通过(本机验证时以 zig 服务在跑为准)。 + const FIXTURES: [(&str, &str); 3] = [ + ("/tmp/fix1.ttf", "/tmp/fix1.woff2"), + ("/tmp/fix2.ttf", "/tmp/fix2.woff2"), + ("/tmp/fix3.ttf", "/tmp/fix3.woff2"), + ]; + + fn load(p: &str) -> Option> { + std::fs::read(p).ok() + } + + /// 读 WOFF2 header 固定字段(offset, 宽, 名) + fn hdr(buf: &[u8], off: usize, len: usize) -> u64 { + let mut v: u64 = 0; + for b in &buf[off..off + len] { + v = (v << 8) | *b as u64; + } + v + } + + /// 遍历 Table Directory,返回 (各 entry 序列化区间, dir 总字节数) + fn walk_dir(buf: &[u8]) -> (Vec<(usize, usize)>, usize) { + let num_tables = hdr(buf, 12, 2) as usize; + let mut pos = WOFF2_HEADER_SIZE; + let mut spans = Vec::new(); + for _ in 0..num_tables { + let start = pos; + pos += 1; // flags + let flags = buf[start]; + if flags & 0x3F == 63 { + pos += 4; // 自定义 tag + } + // UIntBase128 变长:续位 0x80 + while buf[pos] & 0x80 != 0 { + pos += 1; + } + pos += 1; + if flags & 0xC0 == 0 { + // 已变换(glyf/loca):追加 transformLength + while buf[pos] & 0x80 != 0 { + pos += 1; + } + pos += 1; + } + spans.push((start, pos)); + } + (spans, pos - WOFF2_HEADER_SIZE) + } + + #[test] + fn not_sfnt() { + // 仅长度 <12 判 NotSfnt;numTables=0 的 20 字节输入在 Zig 中同样合法编码(空表目录) + assert!(matches!(encode_ttf_to_woff2(&[0u8; 5]), Err(EncodeError::NotSfnt))); + assert!(matches!(encode_ttf_to_woff2(&[0u8; 11]), Err(EncodeError::NotSfnt))); + } + + /// 编码函数逐 fixture 对拍:头部逐字段 + 目录段逐字节 + 体积差 <1% + /// (压缩流与 C brotli 不逐字节一致,属已知实现差异;解码等价由 decode-parity 外部验证) + #[test] + fn encode_fixtures_parity() { + for (ttf_path, oracle_path) in FIXTURES { + let (Some(ttf), Some(oracle)) = (load(ttf_path), load(oracle_path)) else { + eprintln!("skip: fixture 缺失 {ttf_path}(获取方式见 FIXTURES 注释)"); + continue; + }; + let out = encode_ttf_to_woff2(&ttf).expect("encode ok"); + let name = ttf_path.rsplit('/').next().unwrap(); + + // 头部逐字段(除 length/totalCompressedSize 两个依赖压缩流长度的字段外必须一致) + assert_eq!(hdr(&out, 0, 4), hdr(&oracle, 0, 4), "{name} signature"); + assert_eq!(hdr(&out, 4, 4), hdr(&oracle, 4, 4), "{name} flavor"); + assert_eq!(hdr(&out, 12, 2), hdr(&oracle, 12, 2), "{name} numTables"); + assert_eq!(hdr(&out, 14, 2), hdr(&oracle, 14, 2), "{name} reserved"); + assert_eq!(hdr(&out, 16, 4), hdr(&oracle, 16, 4), "{name} totalSfntSize"); + assert_eq!(hdr(&out, 24, 2), 1, "{name} majorVersion"); + assert_eq!(hdr(&out, 26, 2), 0, "{name} minorVersion"); + assert_eq!(hdr(&out, 28, 20), 0, "{name} meta/priv 全零"); + + // 目录段逐字节一致(origLength/transformLength 编码与 C 侧完全相同) + let (out_spans, out_dir_size) = walk_dir(&out); + let (oracle_spans, oracle_dir_size) = walk_dir(&oracle); + assert_eq!(out_dir_size, oracle_dir_size, "{name} 目录段长度"); + for (i, ((os, oe), (rs, re))) in out_spans.iter().zip(&oracle_spans).enumerate() { + assert_eq!((os, oe), (rs, re), "{name} entry{i} 边界"); + assert_eq!(&out[*os..*oe], &oracle[*rs..*re], "{name} entry{i} 字节"); + } + + // 体积差 <1%(压缩流实现差异的量化验收线) + let diff = out.len().abs_diff(oracle.len()); + assert!( + diff * 100 < oracle.len(), + "{name} 体积差 {diff}B 超过 1%(out={} oracle={})", + out.len(), + oracle.len() + ); + eprintln!("{name}: rust={} oracle={} diff={diff}B ({:.3}%)", out.len(), oracle.len(), diff as f64 * 100.0 / oracle.len() as f64); + } + } + + /// UIntBase128 / 255UInt16 / tagIndex 边界用例(对译 Zig 单元语义) + #[test] + fn primitive_encoders() { + assert_eq!(size_u_int_base128(0), 1); + assert_eq!(size_u_int_base128(0x7F), 1); + assert_eq!(size_u_int_base128(0x80), 2); + assert_eq!(size_u_int_base128(0x3FFF), 2); + assert_eq!(size_u_int_base128(0x1FFFFF), 3); + assert_eq!(size_u_int_base128(0x0FFFFFFF), 4); + assert_eq!(size_u_int_base128(u32::MAX), 5); + + let mut buf = [0u8; 8]; + // 0x3FFF=16383=14 位全 1:高 7 位组 127(续位)→ FF,低组 0x7F + assert_eq!(encode_u_int_base128(0x3FFF, &mut buf, 0), 2); + assert_eq!(&buf[..2], &[0xFF, 0x7F]); + assert_eq!(encode_u_int_base128(0x80, &mut buf, 0), 2); + assert_eq!(&buf[..2], &[0x81, 0x00]); + assert_eq!(encode_u_int_base128(0, &mut buf, 0), 1); + assert_eq!(buf[0], 0); + + assert_eq!(size_255_u_int16(252), 1); + assert_eq!(size_255_u_int16(253), 2); + assert_eq!(size_255_u_int16(505), 2); + assert_eq!(size_255_u_int16(506), 2); + assert_eq!(size_255_u_int16(761), 2); + // TS 原版即有的边界不一致:size 用 <=762 判 2 字节,而实际编码 762 走 3 字节形态,bug-for-bug 保留 + assert_eq!(size_255_u_int16(762), 2); + + let mut b3 = [0u8; 3]; + assert_eq!(write_255_u_int16(&mut b3, 0, 100), 1); + assert_eq!(b3[0], 100); + assert_eq!(write_255_u_int16(&mut b3, 0, 300), 2); + assert_eq!(&b3[..2], &[255, 47]); // 300-253 + assert_eq!(write_255_u_int16(&mut b3, 0, 600), 2); + assert_eq!(&b3[..2], &[254, 94]); // 600-506 + assert_eq!(write_255_u_int16(&mut b3, 0, 0x1234), 3); + assert_eq!(&b3[..3], &[253, 0x12, 0x34]); + + assert_eq!(tag_index(b"cmap"), 0); + assert_eq!(tag_index(b"Sill"), 49); + assert_eq!(tag_index(b"DSIG"), 63); + } + + /// 端内一致性:同输入两次编码输出一致(确定性) + #[test] + fn encode_deterministic() { + let Some(ttf) = load("/tmp/fix1.ttf") else { + eprintln!("skip: fixture 缺失 /tmp/fix1.ttf"); + return; + }; + let a = encode_ttf_to_woff2(&ttf).unwrap(); + let b = encode_ttf_to_woff2(&ttf).unwrap(); + assert_eq!(a, b); + } +} diff --git a/rust-spike/verify-parity.sh b/rust-spike/verify-parity.sh new file mode 100755 index 0000000..61f2e0f --- /dev/null +++ b/rust-spike/verify-parity.sh @@ -0,0 +1,55 @@ +#!/usr/bin/env bash +# rust↔zig 双实例字节对拍(Rust 迁移各轮复用的验收工具) +# 用法: ./verify-parity.sh [outType] +# 对每个字体 × 随机文本:两侧请求落盘 cmp,全部一致则 PASS +set -euo pipefail +cd "$(dirname "$0")/.." + +ZIG_PORT=${1:-8090} +RS_PORT=${2:-8094} +OUT_TYPE=${3:-ttf} + +FONTS=( + "鸿蒙黑体.ttf" + "令东齐伋复刻体.ttf" + "悠哉字体.ttf" + "方舟像素字体.ttf" + "思源黑体.ttf" +) + +urlencode() { python3 -c "import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))" "$1"; } + +rand_text() { + # 每次生成不同长度的随机文本(千字文常用字池),防 LRU 缓存命中 + python3 - "$1" <<'EOF' +import random, sys +random.seed(sys.argv[1]) +pool = ('字体工具测试页面永和九年岁在癸丑暮春之初会于会稽山阴之兰亭修禊事也群贤毕至' + '少长咸集此地有崇山峻岭茂林修竹又有清流激湍映带左右引以为流觞曲水列坐其次' + '虽无丝竹管弦之盛一觞一咏亦足以畅叙幽情是日也天朗气清惠风和畅') +n = random.choice([8, 16, 40, 128]) +print(''.join(random.choices(pool, k=n))) +EOF +} + +pass=0; fail=0 +seed=0 +for font in "${FONTS[@]}"; do + for rep in 1 2 3; do + seed=$((seed+1)) + TXT=$(rand_text "$seed") + ENC=$(urlencode "$TXT"); FENC=$(urlencode "$font") + curl -s --noproxy '*' "http://127.0.0.1:${ZIG_PORT}/api?font=${FENC}&text=${ENC}&outType=${OUT_TYPE}" > /tmp/pz.bin + curl -s --noproxy '*' "http://127.0.0.1:${RS_PORT}/api?font=${FENC}&text=${ENC}&outType=${OUT_TYPE}" > /tmp/pr.bin + if cmp -s /tmp/pz.bin /tmp/pr.bin; then + echo "PASS ${font} seed=${seed} $(wc -c < /tmp/pz.bin)B" + pass=$((pass+1)) + else + echo "FAIL ${font} seed=${seed} zig=$(wc -c < /tmp/pz.bin)B rust=$(wc -c < /tmp/pr.bin)B" + fail=$((fail+1)) + fi + done +done +echo "----" +echo "结果: ${pass} PASS / ${fail} FAIL" +[ "$fail" -eq 0 ] diff --git a/src/pages/FontList.vue b/src/pages/FontList.vue index 65665e3..578da5e 100644 --- a/src/pages/FontList.vue +++ b/src/pages/FontList.vue @@ -251,6 +251,7 @@ function onCardAppear(fontName: string) {