演示宽度数组解析

### 文章目录

[@[TOC]](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[一、准备一个最小的 XRef 流示例](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[二、模拟 PDFium 代码执行（逐行 + 内存状态）](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[第1步：读取 /W 数组](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[第2步：加载流数据](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[第3步：解析 /Index 数组](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[第4步：遍历子节中的每个条目](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[条目0 (j = 0, 对象号 = startnum + j = 0)](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[条目1 (j = 1, 对象号 = 1)](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[条目2 (j = 2, 对象号 = 2)](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[第5步：更新 segindex 并结束](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[三、为什么代码要这样设计？------ 设计意图总结](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[四、扩展到其他 W 数组示例](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[示例：`/W [0 4 1]`（类型字段省略）](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[示例：`/W [1 8 0]`（生成号省略）](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[示例：`/W [0 8 0]`（极致压缩）](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)
[五、图解整个流程（结合内存）](#文章目录 @[TOC] 一、准备一个最小的 XRef 流示例二、模拟 PDFium 代码执行（逐行 + 内存状态）第1步：读取 /W 数组第2步：加载流数据第3步：解析 /Index 数组第4步：遍历子节中的每个条目条目0 (j = 0, 对象号 = startnum + j = 0) 条目1 (j = 1, 对象号 = 1) 条目2 (j = 2, 对象号 = 2) 第5步：更新 segindex 并结束三、为什么代码要这样设计？—— 设计意图总结四、扩展到其他 W 数组示例示例：/W [0 4 1]（类型字段省略）示例：/W [1 8 0]（生成号省略）示例：/W [0 8 0]（极致压缩）五、图解整个流程（结合内存）)

一、准备一个最小的 XRef 流示例

假设 PDF 文件中有一个 XRef 流对象（对象号 100）：

pdf 复制代码

100 0 obj
<<
  /Type /XRef
  /Size 5
  /W [1 3 1]            ← 宽度数组：类型1字节，偏移3字节，生成号1字节
  /Index [0 3]          ← 子节：对象0、1、2 都在这个流里
>>
stream
  <二进制数据，十六进制如下>
endstream
endobj

二进制数据（共 3 个条目 × 5 字节/条目 = 15 字节）：

复制代码

地址(相对流起始)  字节(十六进制)   说明
0:              01              条目0 类型=1
1-3:            00 01 00         条目0 偏移 = 0x000100 = 256
4:              00               条目0 生成号=0
-------------------------------------------
5:              02              条目1 类型=2
6-8:            00 00 02         条目1 字段2 = 0x000002 = 2
9:              00               条目1 生成号=0
-------------------------------------------
10:             00              条目2 类型=0
11-13:          00 00 00         条目2 字段2 = 0
14:             00               条目2 生成号=0

目标：解析出对象0、1、2的信息，填入 m_ObjectInfo 映射表。

二、模拟 PDFium 代码执行（逐行 + 内存状态）

第1步：读取 /W 数组

cpp 复制代码

CPDF_Array* pArray = pDict->GetArrayFor("W");
std::vector<uint32_t> WidthArray;
for (size_t i = 0; i < pArray->GetCount(); ++i)
    WidthArray.push_back(pArray->GetIntegerAt(i));

执行后内存：

复制代码

WidthArray[0] = 1
WidthArray[1] = 3
WidthArray[2] = 1

cpp 复制代码

uint32_t totalWidth = WidthArray[0] + WidthArray[1] + WidthArray[2]; // totalWidth = 5

设计原因 ：/W 数组的长度不固定（规范要求至少3个），但这里总是取前3个值。因为每个 XRef 条目恰好由这三个字段组成。totalWidth 用于快速跳转到第 N 个条目（N * totalWidth）。

第2步：加载流数据

cpp 复制代码

auto pAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pStream);
pAcc->LoadAllData();
const uint8_t* pData = pAcc->GetData();   // 指向流数据的第一个字节
uint32_t dwTotalSize = pAcc->GetSize();   // 这里为 15

内存布局（用地址偏移表示）：

复制代码

pData 指向地址0（逻辑地址）
地址0 : 0x01
地址1 : 0x00
地址2 : 0x01
地址3 : 0x00
地址4 : 0x00
地址5 : 0x02
地址6 : 0x00
地址7 : 0x00
地址8 : 0x02
地址9 : 0x00
地址10: 0x00
地址11: 0x00
地址12: 0x00
地址13: 0x00
地址14: 0x00

第3步：解析 /Index 数组

这里我们直接假设 arrIndex 已经被填充为 [(0, 3)]。代码会循环这个数组。

cpp 复制代码

uint32_t segindex = 0;   // 已经处理的条目总数（全局）
for (uint32_t i = 0; i < arrIndex.size(); ++i) {
    int32_t startnum = arrIndex[i].first;   // 0
    uint32_t count = arrIndex[i].second;    // 3
    
    const uint8_t* segstart = pData + segindex * totalWidth; // segstart = pData + 0

设计原因 ：segindex 是之前所有子节已经消耗的条目数。因为条目是连续存储的，所以新子节的开始位置 = 流起始 + 已处理条目数 × 每个条目宽度。

第4步：遍历子节中的每个条目

条目0 (j = 0, 对象号 = startnum + j = 0)

cpp 复制代码

const uint8_t* entrystart = segstart + j * totalWidth; // entrystart = pData + 0

entrystart 指向地址0（第一个条目的开头）。

4.1 读取类型

cpp 复制代码

int32_t type = 1;
if (WidthArray[0] > 0)   // 1 > 0，成立
    type = GetVarInt(entrystart, WidthArray[0]);

GetVarInt(entrystart, 1) 做什么？

cpp 复制代码

uint32_t GetVarInt(const uint8_t* p, int32_t n) {
    uint32_t result = 0;
    for (int32_t i = 0; i < n; ++i)
        result = result * 256 + p[i];
    return result;
}

n=1, p[0]=0x01 → result = 0*256 + 1 = 1
返回 1

type = 1

设计原因 ：GetVarInt 用 *256 是因为这是大端序转换的标准方法：每读一个新字节，就把之前的结果左移8位（乘以256），然后加上新字节。循环可以处理任意宽度（1~8字节），可移植且无字节序依赖。

4.2 读取字段2

cpp 复制代码

FX_FILESIZE field2 = 0;
if (WidthArray[1] > 0)   // 3 > 0
    field2 = GetVarInt(entrystart + WidthArray[0], WidthArray[1]);

entrystart + WidthArray[0] = 地址0 + 1 = 地址1
GetVarInt(地址1, 3) 读取地址1,2,3 的三个字节：0x00, 0x01, 0x00

计算：

i=0: result = 0*256 + 0 = 0
i=1: result = 0*256 + 1 = 1
i=2: result = 1*256 + 0 = 256
field2 = 256

4.3 读取生成号

cpp 复制代码

int32_t gen = 0;
if (WidthArray[2] > 0)   // 1 > 0
    gen = GetVarInt(entrystart + WidthArray[0] + WidthArray[1], WidthArray[2]);

entrystart + 1 + 3 = 地址4
GetVarInt(地址4, 1) 读取 0x00 → 0
gen = 0

4.4 根据类型存储

cpp 复制代码

uint32_t objnum = startnum + j;   // 0
if (type == 0) {
    // 空闲对象
    m_ObjectInfo[objnum].pos = 0;
    m_ObjectInfo[objnum].type = 0;
} else {
    m_ObjectInfo[objnum].pos = field2;    // pos = 256
    m_ObjectInfo[objnum].gennum = gen;    // gennum = 0
    if (type == 1) {
        m_ObjectInfo[objnum].type = 1;
        m_SortedOffset.insert(field2);    // 记录偏移 256
    } else if (type == 2) {
        m_ObjectInfo[objnum].type = 2;
        m_ObjectInfo[field2].type = 255;  // 标记对象流
    }
}

因为 type == 1，所以执行：

复制代码

m_ObjectInfo[0] = {pos=256, gennum=0, type=1}
m_SortedOffset 插入 256

当前内存状态：

复制代码

m_ObjectInfo 是一个 map（对象号 → 结构）：
  0 -> {pos=256, gennum=0, type=1}
m_SortedOffset = {256}

条目1 (j = 1, 对象号 = 1)

cpp 复制代码

entrystart = segstart + 1 * totalWidth = pData + 5

entrystart 指向地址5（第二个条目的开头）。

读取类型 ：GetVarInt(地址5, 1) → 地址5 = 0x02 → 2
type = 2

读取字段2 ：GetVarInt(地址6, 3) → 地址6=0x00, 地址7=0x00, 地址8=0x02 → 0x000002 = 2
field2 = 2

读取生成号 ：GetVarInt(地址9, 1) → 0x00 → 0
gen = 0

存储：objnum = 1, type == 2

复制代码

m_ObjectInfo[1] = {pos=2, gennum=0, type=2}
m_ObjectInfo[2].type = 255   // 注意：field2=2，所以是对象2被标记为对象流容器

当前内存状态：

复制代码

m_ObjectInfo:
  0 -> {256,0,1}
  1 -> {2,0,2}
  2 -> {pos未设置, gennum未设置, type=255}  // 其他字段保持默认（0）
m_SortedOffset = {256}

条目2 (j = 2, 对象号 = 2)

cpp 复制代码

entrystart = segstart + 2 * totalWidth = pData + 10

读取类型 ：GetVarInt(地址10, 1) → 0x00 → 0
type = 0

读取字段2 ：GetVarInt(地址11, 3) → 0x00,0x00,0x00 → 0
field2 = 0

读取生成号 ：GetVarInt(地址14, 1) → 0x00 → 0
gen = 0

存储：type == 0

复制代码

m_ObjectInfo[2].pos = 0;
m_ObjectInfo[2].type = 0;
// 注意：之前条目1已经把 m_ObjectInfo[2].type 设为 255，现在会被覆盖为 0！
// 这取决于处理顺序。实际上，XRef 流中的条目应该按照对象号递增顺序，后面的条目不应该覆盖前面的。但这里我们的 Index 包含了对象2，它自己是一个空闲对象，同时之前又被标记为对象流，矛盾了。这个例子说明：一个对象号不应该同时出现在两个角色中。实际 PDF 中不会这样。我们忽略这个矛盾，仅展示解析流程。

为了清晰，我们修正示例：让条目1的 field2=3（对象流3），这样就不会冲突。但为了不使例子复杂，我们接受这个矛盾，重点是理解解析过程。

最终 m_ObjectInfo（假设无冲突）：

复制代码

0: {pos=256, gennum=0, type=1}
1: {pos=2,   gennum=0, type=2}
2: {pos=0,   gennum=0, type=0}
m_SortedOffset: {256}

第5步：更新 segindex 并结束

cpp 复制代码

segindex += count;   // segindex = 0 + 3 = 3

循环结束，函数返回 true。

三、为什么代码要这样设计？------ 设计意图总结

代码模式	原因
动态读取 `/W`	条目格式可变，不能硬编码宽度
`WidthArray` 存储三个宽度	每个条目由三个字段组成，分别处理
`totalWidth` 预计算	支持 O(1) 跳转到任意条目，提高性能
宽度为 0 时使用默认值	省略不必要的字段，节省存储空间（规范要求）
`GetVarInt` 循环累加 `*256`	将大端字节序列转换为整数，跨平台、任意宽度
指针偏移计算 `entrystart + WidthArray[0]`	动态跳过已读字段，读取下一个字段
类型分支 (type == 1/2/0)	区分未压缩对象、压缩对象、空闲对象，执行不同逻辑
压缩对象时标记对象流 (type=255)	延迟解析对象流，提高效率
`/Index` 循环 + `segindex`	支持稀疏对象号，只存储存在的对象

四、扩展到其他 W 数组示例

示例：`/W [0 4 1]`（类型字段省略）

流中每个条目只有 0+4+1=5 字节，没有类型字节。代码执行时：

WidthArray[0] = 0 → type 保持默认值 1。
字段2 从 entrystart + 0 开始读 4 字节。
生成号从 entrystart + 4 读 1 字节。

效果：所有对象都被当作未压缩对象（type=1），节省 1 字节/条目。

示例：`/W [1 8 0]`（生成号省略）

WidthArray[2] = 0 → gen 保持默认值 0。
字段2 读 8 字节，支持超大文件（64 位偏移）。

示例：`/W [0 8 0]`（极致压缩）

类型默认 1，生成号默认 0。
每个条目只存 8 字节偏移，无任何额外信息。

五、图解整个流程（结合内存）

复制代码

PDF 文件中的 XRef 流（W=[1,3,1]）
┌───────┬───────────────┬───────┐
│ 0x01  │ 0x00 0x01 0x00│ 0x00  │  ← 条目0
├───────┼───────────────┼───────┤
│ 0x02  │ 0x00 0x00 0x02│ 0x00  │  ← 条目1
├───────┼───────────────┼───────┤
│ 0x00  │ 0x00 0x00 0x00│ 0x00  │  ← 条目2
└───────┴───────────────┴───────┘

PDFium 解析过程：

WidthArray = [1,3,1]; totalWidth=5

pData ──┐
        ▼
    ┌─────────────────────────────┐
    │ 条目0                        │
    │ type = GetVarInt(pData,1)=1  │
    │ field2 = GetVarInt(pData+1,3)=256 │
    │ gen = GetVarInt(pData+4,1)=0      │
    └─────────────────────────────┘
pData+5 ──► 条目1 ...

我希望这次模拟执行的方式能让您彻底理解每一个步骤。如果还有任何不清楚的地方，请指出具体哪一行代码或哪一个字节的转换，我会进一步细化。

演示宽度数组解析

### 文章目录

一、准备一个最小的 XRef 流示例

二、模拟 PDFium 代码执行（逐行 + 内存状态）

第1步：读取 /W 数组

第2步：加载流数据

第3步：解析 /Index 数组

第4步：遍历子节中的每个条目

条目0 (j = 0, 对象号 = startnum + j = 0)

条目1 (j = 1, 对象号 = 1)

条目2 (j = 2, 对象号 = 2)

第5步：更新 segindex 并结束

三、为什么代码要这样设计？------ 设计意图总结

四、扩展到其他 W 数组示例

示例：/W [0 4 1]（类型字段省略）

示例：/W [1 8 0]（生成号省略）

示例：/W [0 8 0]（极致压缩）

五、图解整个流程（结合内存）

示例：`/W [0 4 1]`（类型字段省略）

示例：`/W [1 8 0]`（生成号省略）

示例：`/W [0 8 0]`（极致压缩）