上一篇把 SVF1 的字段表定完了,但一份规范只有变成代码才算数。这一篇从空文件开始:先生成 120 帧 64×48 的合成画面,用帧内 RLE 加与上一帧的差分把它们压进 .svf1,再从文件里读回样本表和索引,在三个不同时间点做 seek,最后把解码结果和原始帧逐字节比对。

选择 RLE 加差分,是因为它足够简单,能在几十行里讲清楚封装和解码的每一步,而且它是无损的,校验结果只有对和错,没有「看起来差不多」这种模糊地带。它不是能替代 H.264 的视频编码,真实摄像头画面用这套方案会压不动,这一点最后一节会明确说。

下面所有数字都来自本机实际运行,Python 3.15,只用标准库 struct、hashlib、bisect 和 os。脚本放在临时目录,不放进文档仓库。你可以照着复现,也可以只看输出,先理解 seek 那几步在做什么。

现象真实原因第一步查什么
seek 到 2.2 秒,命中的关键帧时间却是 1.98 秒索引只记关键帧,二分找的是目标之前最近的一个确认二分用的是 bisect_right 并减一,且关键帧间隔是 1 秒
解码结果和原始帧对不上差分方向写反,或 RLE 解码时把计数和值读颠倒先用关键帧单独解码校验,再测非关键帧
文件比原始像素还大画面噪声多,RLE 用两个字节表示一个字节,越压越大统计编码前后字节数,确认数据是否有长游程
索引偏移对不上,seek 读到帧数据中间写头部时按估算长度填了 index_offset,实际 payload 长度不同打印 payload_base、每帧大小累加值和最终 index_offset
文件尾多出 64 字节,读取端报长度不符索引本身占空间,计算文件大小时漏加了 index_count 乘 16用 index_offset 加条目数乘 16 再和实际文件大小对比
目标时间超过时长,程序读到越界没有把目标帧号限制在 0 到样本数减一之间在 seek 入口 clamp 时间,再 clamp 帧号
解码时数组下标越界样本的 offset 加 size 超过了帧数据区末尾读取前校验 offset 和 size 都在 index_offset 以内
样本数写成 121,最后一帧是空的循环边界多算了一帧,或者把索引条目数当成样本数比较 len(samples) 和轨道表里的 sample_count

编码方案:关键帧全量,其余帧只存差分

每帧是 64×48 的灰度图,3072 个字节。关键帧把整帧像素做游程编码,也就是 RLE:把连续相同的字节写成「重复次数加值」两个字节,比如二十个 255 写成 14 FF。非关键帧先和上一帧逐像素相减,差值对 256 取模,得到一张差分图,再对差分图做同样的 RLE。连续不变的区域差值为 0,会形成很长的游程,压得很小。

解码方向相反:先 RLE 解出差分图,再逐像素加上上一帧,对 256 取模。关键帧的上一帧当作全零,所以同一套解码路径既能解关键帧也能解差分帧,不用分支处理绝对像素。这是设计上的一个小技巧,少一个分支就少一类边界错误。

RLE 的格式很简单:每两个字节一组,第一个是重复次数,范围 1 到 255,第二个是要重复的值。没有结束标记,解到 payload 末尾就停。这样设计的前提是解码端知道 payload 有多长,而长度正好在样本表里。如果长度字段错了,RLE 会多解或少解,校验就会失败,而不是悄悄产出错误画面。

def rle_encode(data):
    out = bytearray()
    i, n = 0, len(data)
    while i < n:
        v = data[i]
        j = i + 1
        while j < n and data[j] == v and j - i < 255:
            j += 1
        out.append(j - i)
        out.append(v)
        i = j
    return bytes(out)

def rle_decode(data):
    out = bytearray()
    for k in range(0, len(data), 2):
        out.extend([data[k + 1]] * data[k])
    return bytes(out)

编码和解码都只用标准库,没有第三方依赖。注意 j - i < 255 这个上限,一个游程最多 255 个字节,超过就要拆成两组。如果不拆,计数会溢出成一个字节放不下的值,struct 写入时直接报错,或者更糟,被截断成错误的小数字。

def encode_frame(cur, prev, key):
    if key:
        return rle_encode(cur)
    diff = bytes((cur[p] - prev[p]) & 0xFF for p in range(len(cur)))
    return rle_encode(diff)

def decode_frame(payload, prev, key):
    raw = rle_decode(payload)
    if key:
        return raw
    return bytes((prev[p] + raw[p]) & 0xFF for p in range(len(prev)))

关键帧这里直接 rle_encode(cur),等价于「上一帧是全零、差分为原值」。解码端遇到关键帧直接返回 raw,不再加 prev。两条路径在实现上分开,但在数学上是一致的,选哪种写法取决于你更在意代码短还是逻辑统一。

关键帧:完整记录整帧

不依赖任何其它帧,单独拿出来就能解。代价是体积大,本例中关键帧最大 416 字节,是平均差分帧的两倍多。它同时承担随机访问入口和错误恢复起点的作用。

差分帧:只记变化

和上一帧逐像素相减,静止区域全是 0,RLE 后非常小,本例平均 155 字节、最小 144 字节。代价是必须按顺序解码,丢一帧后面全错,只能等下一个关键帧恢复。

mux:两遍布局,先算长度再写头

封装的关键不是写字节,而是先算清楚每个东西放在哪。SVF1 的布局是「头、轨道表、样本表、帧数据、索引」,样本表长度只跟帧数有关,可以先算;帧数据长度要等每帧编码完才知道;索引长度只跟关键帧数有关。所以流程分两遍:第一遍编码所有帧、记录每帧大小和偏移,第二遍按算好的位置写文件。

先算 payload_base:32 字节头,加 24 字节轨道表,加 120 条样本表每条 24 字节,等于 32 加 24 加 2880,得到 2936。第一帧的偏移就是 2936。之后每写一帧,偏移加上这一帧的编码长度。所有帧写完,当前位置就是索引偏移。本例最后一帧结束后在 21600,索引从那里开始,4 条每条 16 字节,文件总长 21664。

payload_base = HEADER.size + TRACK.size + n * SAMPLE.size
payloads, samples = [], []
prev = bytes(W * H)
off = payload_base
for i, cur in enumerate(frames):
    key = i % KEY_INTERVAL == 0
    enc = encode_frame(cur, prev, key)
    payloads.append(enc)
    samples.append((off, len(enc), i * FRAME_MS, FRAME_MS,
                    1 if key else 0, 0))
    off += len(enc)
    prev = cur

index_offset = off
duration = n * FRAME_MS
f.write(HEADER.pack(MAGIC, 1, 0, TIMESCALE, duration, 1,
                    HEADER.size, index_offset, len(keyframes), 0))

这里有一个顺序问题:HEADER.pack 需要 index_offset,而 index_offset 要等所有帧编码完才知道。所以不能边编码边写头,必须先把 payload 留在内存里,或者先写一个占位头,最后再回填。本例帧数少,直接留在内存里最简单。真实录制工具帧数多,通常先写占位头,关闭文件前用 seek 回到头部改写。

样本表每条记录五个值:偏移、大小、时间戳、时长、标志。时间戳是 i * FRAME_MS,本例 FRAME_MS 是 33,所以第 30 帧是 990,第 60 帧是 1980,第 90 帧是 2970。注意 120 帧总时长是 3960 毫秒,最后一帧从 3894 开始,显示 33 毫秒,结束在 3927,和 3960 差 33。这个差是帧时长取整造成的,规范里用总时长单独记,读取端不要拿最后一帧的结束时间当总时长。

样本表每条 24 字节,120 条就是 2880 字节,占整个文件的百分之十三左右。用固定字段换读取简单,是这类小格式的常见取舍:多花一点索引空间,换来不用解析变长结构,读取端几十行就能完成。

mux 的写入顺序
编码所有帧
算出偏移和索引位置
写头与轨道表
写样本表和帧数据
写索引并核对总长

写完以后要核对两件事:文件实际大小是不是 index_offset 加 index_count 乘 16;第一个样本的 offset 是不是 payload_base。这两个等式只要有一个不成立,就说明偏移算错了,读取端一定会出问题。本例 21600 加 4 乘 16 等于 21664,和实际文件大小一致;第一帧偏移 2936,和 payload_base 一致。

demux 与 seek:先读索引,再顺序解码

读取端的第一步是读 32 字节头,检查 magic 是不是 SVF1,版本是不是 1。然后按 header_size 跳到轨道表,读第一条轨道的宽高、编码和样本数。接着读样本表,每条 24 字节,读 sample_count 条。最后按 index_offset 跳到索引,读 index_count 条,每条 16 字节。整个读取过程不需要碰帧数据,直到真正要解码某一帧。

seek 的函数接收一个毫秒时间。它先取出索引里的时间戳列表,用 bisect_right 找到插入位置再减一,得到最后一个时间戳小于等于目标的关键帧。这个条目给出样本序号和文件偏移。然后从样本序号开始,一帧一帧解码到目标帧。目标帧号是目标毫秒除以每帧毫秒再向下取整,并且要 clamp 到样本数减一,防止超过时长时越界。

def decode_from_key(data, samples, index, target_ms):
    ts_list = [e[0] for e in index]
    k = bisect.bisect_right(ts_list, target_ms) - 1
    k = max(0, k)
    ts, sample_idx, _ = index[k]
    frame_no = min(target_ms // FRAME_MS, len(samples) - 1)
    prev = bytes(W * H)
    cur = None
    for i in range(sample_idx, frame_no + 1):
        off, size, _, _, flags, _ = samples[i]
        payload = data[off:off + size]
        cur = decode_frame(payload, prev, flags & 1)
        prev = cur
    return k, ts, sample_idx, frame_no, cur

为什么用 bisect_right 再减一,而不是 bisect_left?因为目标时间正好落在某个关键帧的时间戳上时,我们要的就是这个关键帧,而不是它前面那个。bisect_right 返回的是插入到相等元素之后的位置,减一正好落在相等元素本身。bisect_left 返回相等元素之前的位置,减一会跳到上一个关键帧,白白多解一个 GOP。

解码循环里有一个容易写错的地方:prev 的初始值。关键帧不需要参考上一帧,但循环仍然把 prev 传进去。因为关键帧分支直接返回 raw,不使用 prev,所以初值给全零是安全的。如果实现成「关键帧也加 prev」,初值就必须是解码器上一帧的真实状态,否则第一帧会偏。本例选择了不依赖 prev 的关键帧分支,避免了这个状态问题。

seek 到 2.2 秒时,目标帧号是 66,时间戳 2178 毫秒;命中的关键帧是 60,时间戳 1980 毫秒。也就是说,用户看到的是 2.178 秒那一帧,而解码是从 1.98 秒开始的。中间差了 6 帧,这就是 seek 需要顺序解码的部分,也是「拖过去画面会慢半拍」的来源。

实测:21664 字节,三个时间点都对得上

脚本在临时目录生成 120 帧,每帧 64×48,30 帧每秒,timescale 设 1000,关键帧每 30 帧一个,也就是每秒一个。运行命令是 python svf1_demo.py,完整输出如下,数字没有做任何修饰。

frames=120 64x48 fps=30 timescale=1000
file=21664 bytes keyframes=4
header_bytes=53 56 46 31 01 00 00 00 e8 03 00 00 78 0f 00 00 01 00 20 00 60 54 00 00 04 00 00 00 00 00 00 00
payload_base=2936 sizes min=144 max=416 avg=155
index_offset=21600 index_count=4
demux tracks=1 samples=120 index=4
seek target=500ms -> keyframe#0 ts=0ms decode frames 0..15 checksum=487d8728aef39827 match=True
seek target=2200ms -> keyframe#60 ts=1980ms decode frames 60..66 checksum=67795b86fb119a26 match=True
seek target=3900ms -> keyframe#90 ts=2970ms decode frames 90..118 checksum=c87d34a7a60c8b59 match=True

逐行看。120 帧、64×48、30 帧每秒,和生成参数一致。文件 21664 字节,关键帧 4 个。文件头 32 字节的十六进制和上一篇文章手算的完全一样:magic 是 SVF1,timescale 是 1000,duration 是 3960,轨道数 1,头部长度 32,索引偏移 21600,索引条目 4。

payload_base 是 2936,也就是 32 加 24 加 120 乘 24。每帧编码后最小 144 字节,最大 416 字节,平均 155 字节。最大的是关键帧,因为整帧都要记录;最小的是变化很少的差分帧。120 帧原始像素总共 368640 字节,压到 18664 字节的帧数据,比例接近 20 比 1。这个比例只对当前这种块状合成画面成立,换成真实照片会差很多。

解封装读回 1 条轨道、120 条样本、4 条索引,和写入时一致。三个 seek 的结果如下:

目标时间命中关键帧解码范围校验
500ms序号 0,时间戳 0ms第 0 帧到第 15 帧checksum 487d8728aef39827,match=True
2200ms序号 60,时间戳 1980ms第 60 帧到第 66 帧checksum 67795b86fb119a26,match=True
3900ms序号 90,时间戳 2970ms第 90 帧到第 118 帧checksum c87d34a7a60c8b59,match=True

三个 match 都是 True,说明解码出来的帧和生成时的原始帧逐字节一致。校验用的是 SHA-1 的前十六位十六进制,只用来快速比对,不作为安全哈希。三次的 checksum 不同,是因为三帧画面不同,不是解码不稳定。

注意第三个 seek,目标 3.9 秒,实际解到第 118 帧,因为总帧数是 120,第 119 帧的时间戳是 3927 毫秒,超过 3900,所以向下取整落在 118。如果目标时间写成 3960,也就是时长本身,clamp 会把帧号压到 119,避免读越界。这个边界在真实播放器里非常常见,用户拖动到最右边时,传入的时间经常正好等于总时长。

边界与代价:这套方案能做什么,不能做什么

首先要明确,RLE 加差分不是视频编码器,它只是无损的字节压缩。它没有运动估计,没有变换和量化,也没有熵编码。它能压动当前画面,是因为合成帧由大块纯色组成,差分后大片为零。换成手机拍的画面,传感器噪声会让每个像素都轻微变化,差分图几乎没有长游程,RLE 可能比原始像素还大。

第二个边界是关键帧间隔。本例每秒一个关键帧,seek 最多解 30 帧,很快。如果改成每 10 秒一个,seek 最多要解 300 帧,虽然 64×48 的帧很小,速度还行,但真实 1080p 画面就会明显卡。索引只记录关键帧,不记录每个 GOP 的结束位置,所以 seek 的代价完全由关键帧间隔决定。

第三个边界是文件大小和内存。本例把整个文件和所有 payload 都放在内存里,因为只有 21KB。真实录制几个 GB,必须边编码边写,索引最后回填。读取端也不能一次读完整份文件,要按样本偏移按需读取。这套代码是教学版,不是可以直接上生产的实现。

限制表现什么时候会咬人
RLE 只适合长游程高频噪声下编码后反而更大真实摄像头画面、胶片颗粒、雨雪场景
差分对运动敏感镜头平移时整帧都在变,差分图全是非零值手持拍摄、快速摇镜、运动物体占比大
无熵编码差值分布不均匀时仍有浪费想进一步压缩但不想换编码器
关键帧间隔固定seek 最坏要解一整个 GOP长 GOP 加高分辨率,拖动明显变慢
索引在文件尾网络播放要先取尾部HTTP 不支持 Range,或 CDN 不缓存尾部
32 位时间戳timescale 90000 时约 13.2 小时溢出长时间连续录制、监控存档

还有一个隐性代价是错误传播。差分帧依赖上一帧,一帧解码错了,后面整组都会错,直到下一个关键帧才恢复。RLE 本身没有校验,一个字节坏掉可能让后续游程全偏。真实格式要在文件级或块级加校验和,发现坏了就跳到下一个关键帧,而不是继续解。

不要把这个示例当成「自己实现视频编码器」的起点去直接处理真实视频。RLE 加差分在真实画面上通常压不动,而且没有色彩空间、音频、可变帧率和错误恢复。它的价值在于把封装、索引和 seek 的流程跑通,理解每个字段为什么存在。

如果要继续往前走,下一步通常不是换更复杂的 RLE,而是引入分块变换和量化,再对系数做熵编码。那才是 H.264 这类编码器的方向。也可以先做一个「只换封装」的版本,把已有编码器的帧原样装进 SVF1,验证索引和 seek 的逻辑,再考虑编码。

当天能自己验证的五个练习

  1. 把关键帧间隔从 30 改成 60,重新生成文件,记录文件大小和三个 seek 各自解码的帧数。
  2. 把帧尺寸从 64×48 改成 128×96,观察文件大小是否按像素数线性增长,RLE 比例有没有变化。
  3. 在生成帧里加一段随机噪声,重新封装,记录编码后大小,验证「噪声让 RLE 变大」。
  4. 把索引条目故意删掉一条,跑 seek,观察二分查找命中哪个关键帧,解码校验是否失败。
  5. 把某个样本的 size 改大 8 字节,运行读取端,确认边界校验能拦住,而不是读出错误画面。

小结

三句话:SVF1 用两遍写入解决「头里要填索引位置、索引要等帧写完」的顺序矛盾;seek 先二分关键帧索引,再从关键帧顺序解码到目标帧;RLE 加差分是无损的字节压缩,只适合长游程和低变化画面,不是通用视频编码。

本机实测的文件是 21664 字节,120 帧,4 个关键帧,索引从 21600 开始。三个 seek 分别命中关键帧 0、60、90,解码结果与原始帧的校验全部为 True。这套流程把前面几篇的容器、时间戳、关键帧概念落到了具体字节上,也说明了为什么真实格式还要处理音频、色彩、错误恢复和更长的时间戳。

如果继续往下做,可以把 SVF1 扩展到多轨道:给音频单独一张样本表,用同一个 timescale 对齐,seek 时两条轨道各自找关键帧。到那一步,你做的就已经是一个小型容器,而不是一个录制工具的私有格式了。