客服系统升级后,测试同事反馈一个很难复现的问题:弱网下每两三分钟出现一次「咔」的爆音,随后半秒左右的静音。日志里能看到序号从 1837 跳到 1845,中间八帧没到。开发先怀疑是扬声器,换了耳机,爆音还在;又怀疑是解码库,换成另一个版本,现象照旧。

真正的原因在解码器的丢帧处理:收到空档后,它直接在样本数组里填零。上一帧最后一个样本还在正 18000 附近,下一个样本突然变成 0,波形出现一个垂直的阶跃。扬声器把这个阶跃放成「咔」,后续的静音又让人以为音频断了。补偿逻辑只做了「补零」,没有考虑波形连续,也没有考虑缺口有多长。

这篇把上一篇定义的 SAUD 格式真正跑起来:用 Python 标准库写编码器和解码器,编码一个 2 秒的文件,模拟连续丢三帧,再用前帧重复加淡出的办法补偿。所有数字都来自本机实际运行,包括文件字节数、总帧数、丢帧序号和补偿前后的样本误差。先看清楚损失有多大,再谈怎么遮。

现象真实原因第一步查什么
丢帧处出现短促的「咔」补零或突然切换波形,造成样本值阶跃看补偿段的首尾是否做了淡入淡出,阶跃差有多大
补偿后声音像断续的蜂鸣重复的前帧与后续帧相位不连续,周期性叠在一起检查重复帧的相位、重复次数和淡出曲线
一次丢包后静音越来越长解码器一直补零,直到超时才恢复用时间戳算出缺口长度,给补偿设上限
解码器读越界崩溃payload_len 超过剩余字节,或者超过帧上限读帧头后先校验长度范围和剩余字节数
文件尾部读一半就报错最后一帧不完整,或者 total_frames 写多了逐帧读,检查剩余字节是否够一个完整帧
重传的帧被播放了两遍没有按 seq 去重,收到旧帧也照单全收维护期望序号,丢弃小于期望值的帧
补偿后音画慢慢不同步用样本数补时间,没有按时间戳重新对齐以 timestamp_ms 为播放基准,补偿不能改变时间轴
24 位流解码后数值乱跳3 字节样本没有按 3 字节解包,符号扩展写错按位深分支处理,确认打包方式和字节序

编码器:把样本切成 10 毫秒一帧

编码器做的事很直接:读入整数样本,按 frame_samples 切片,每一片前面加 16 字节帧头,最后把文件头和所有帧写进同一个文件。文件头声明全局规格,帧头声明序号、时间戳和长度。示例用 48kHz、单声道、16 位、480 样本一帧,正好 10 毫秒。

时间戳从 timestamp_base 开始,每帧加 10 毫秒。这是示例信号的理想情况;真实采集时应该用回调时间或墙钟时间,不要用「上一帧加 10」硬推,否则设备时钟一偏,时间戳就跟着偏。

import struct, math

SR, CH, BITS = 48000, 1, 16
FRAME_SAMPLES, TOTAL_FRAMES = 480, 200
TS_BASE = 1762400000000
HEADER_FMT = "<4sBBBB I H H I Q"
FRAME_HDR_FMT = "<I Q H H"

def make_signal():
    n = TOTAL_FRAMES * FRAME_SAMPLES
    out = []
    for i in range(n):
        t = i / SR
        env = 0.62 + 0.16 * math.sin(2 * math.pi * 0.5 * t)
        p1 = 2 * math.pi * 400 * t
        p2 = 2 * math.pi * 800 * t
        out.append(int(round(env * 32767 * (0.7 * math.sin(p1) + 0.3 * math.sin(p2))))
    return out

def encode(path, samples):
    with open(path, "wb") as f:
        f.write(struct.pack(HEADER_FMT, b"SAUD", 1, CH, BITS, 0, SR,
                            FRAME_SAMPLES, FRAME_SAMPLES * CH * BITS // 8,
                            TOTAL_FRAMES, TS_BASE))
        for seq in range(TOTAL_FRAMES):
            chunk = samples[seq * FRAME_SAMPLES:(seq + 1) * FRAME_SAMPLES]
            payload = struct.pack("<%dh" % len(chunk), *chunk)
            f.write(struct.pack(FRAME_HDR_FMT, seq, TS_BASE + seq * 10,
                                len(payload), 0))
            f.write(payload)

这里有几个细节值得注意。文件的 frame_bytes 字段写的是样本区大小,也就是 960,不是帧总长 976;解码器要自己加上 16 字节帧头。每帧的 payload_len 也写 960,这样即使帧头损坏,解码器仍能用文件头里的规格做一次交叉校验。

样本用 struct.pack 按小端打包,一次打包 480 个 short,比逐个写快很多。真实项目里如果要处理 24 位,不能直接用 short,需要按 3 字节打包,或者先转成 32 位再截断。位深不同,打包方式就不同,不能一套代码硬套。

编码器的输出字节数可以直接对账:每个样本 2 字节,每帧再加 16 字节,文件头再 28 字节。对不上时,先查是不是有帧被重复写入,或者最后一帧没写满。实时写入还要考虑磁盘缓冲,别在采集回调里做同步 IO,否则一次卡顿就会丢样本。

解码器:先校验,再还原

解码器比编码器更需要防守。它面对的是可能损坏、截断、伪造的输入,任何一个字段都不能无条件相信。第一步读文件头,校验 magic、版本、声道、位深、帧长和帧字节数是否在合理范围;第二步循环读帧,每读一帧都检查帧头长度和剩余字节。

def decode(path):
    frames = []
    with open(path, "rb") as f:
        head = struct.unpack(HEADER_FMT, f.read(28))
        while True:
            hdr = f.read(16)
            if len(hdr) < 16:
                break
            seq, ts, plen, flags = struct.unpack(FRAME_HDR_FMT, hdr)
            if plen > head[7]:
                raise ValueError("payload too large")
            payload = f.read(plen)
            if len(payload) < plen:
                raise ValueError("truncated frame %d" % seq)
            samples = struct.unpack("<%dh" % (plen // 2), payload)
            frames.append((seq, ts, samples))
    return head, frames

实际跑完,文件头解析成 (b'SAUD', 1, 1, 16, 0, 48000, 480, 960, 200, 1762400000000)。200 帧全部读回,逐样本和原始信号比较,roundtrip_equal 为 True。也就是说,在没有丢帧的情况下,这套编码器是无损的,一个样本都没错。

真实解码器还要多做两件事:按 seq 排序和去重。网络可能乱序,也可能重传,解码器应该维护一个期望序号,收到小于期望值的帧就丢弃,收到大于期望值的帧就记为缺口。示例为了聚焦丢帧补偿,先把这一层简化了。

另外,不要在解码时一次性把整个文件读进内存再处理。2 秒的文件只有 195KB,看不出问题;两小时的直播就是几百兆,一次性读会直接把内存打满。正确做法是流式读,每帧处理完就交给播放缓冲,帧数据不长期保留。

校验顺序也有讲究:先读固定长度,再读变长部分。文件头固定 28 字节,帧头固定 16 字节,样本区长度由帧头决定。只要先把固定部分读完,就能在申请内存之前知道这一帧有多大。反过来,先按最大长度申请再读,遇到畸形文件就会浪费内存,甚至被拖垮。

真实运行结果:195,228 字节,200 帧

编码完成后的实际输出如下:

header_bytes=28 frame_header=16 payload=960 frame_total=976
file_bytes=195228 total_frames=200 duration_ms=2000
header_hex: 53 41 55 44 01 01 10 00 80 BB 00 00 E0 01 C0 03
C8 00 00 00 00 D8 39 57 9A 01 00 00

文件 195,228 字节,等于 28 字节文件头加 200 乘 976 字节帧。200 帧乘 10 毫秒正好 2 秒。帧头开销是 200 乘 16 加 28,等于 3,228 字节,占文件约 1.65%。这个比例和上一篇表格里算的 1.64% 对得上,差的那一点是 28 字节文件头。

文件头十六进制和上一篇的格式定义完全一致:magic 是 SAUD,版本 1,单声道,16 位,采样率 48000,帧长 480,帧字节 960,总帧数 200,时间戳基准 1,762,400,000,000。解码器读回来以后,这些字段都能对上,说明编码器没有把字段顺序或类型写错。

这里顺便验证了一个容易忽略的点:帧总长是 976,不是 960。如果解码器直接用 frame_bytes 去跳帧,下一帧会读到样本中间,从第二个帧开始全错。文件头里的 frame_bytes 只描述样本区,帧头的 16 字节必须单独加。如果这个账对不上,先别怀疑格式,先检查写入循环是不是多写了一帧,或者最后一帧的样本数没有截断。

模拟丢帧:少了 30 毫秒

把第 40、41、42 帧从文件里删掉,模拟连续丢包。这三帧覆盖 480 乘 3 等于 1440 个样本,48kHz 下正好 30 毫秒。解码器收到的是序号 39 之后直接跳到 43,中间空了三个序号。

最粗糙的处理是补零。解码器在缺口位置填 1440 个零,然后继续读第 43 帧。这样做的结果是:缺口里的信号完全消失,误差等于原始信号本身;缺口结束时,波形从零突然跳回第 43 帧的第一个样本,产生一个阶跃。实测数据如下:

== 丢帧 [40, 41, 42],共 1440 个样本(30 ms)==
baseline: rms_err=13662.50 peak_err=22033 snr=0.00 dB

补零的 RMS 误差是 13,662.50,峰值误差 22,033。因为基准就是「零信号减去原始信号」,误差等于原信号,所以信噪比是 0 分贝。这个数字说明:补零不是「损失很小」,而是「整段内容全丢了」,只是耳朵可能把 30 毫秒的空白当成一次短暂停顿。

真实系统里,补零还会带来另一个问题:播放缓冲的写指针和读指针会因为这个缺口错位。如果解码器按「每帧固定 960 字节」推进,而文件里缺了三帧,后续帧的序号和时间戳都会对不上,补偿逻辑必须先按时间戳把时间轴补齐,再谈波形。

补偿:重复前帧,末尾淡出

补偿的思路是拿缺口前最后一帧的样本,重复填进缺口,再在缺口末尾做淡出。重复让波形有内容,淡出让结尾平滑地落到零,避免直接跳到下一帧时产生阶跃。下面这段代码取第 39 帧,循环填满 1440 个样本,最后 5 毫秒线性淡出。

LOST = [40, 41, 42]
gap_len = len(LOST) * FRAME_SAMPLES
prev = frames[LOST[0] - 1][2]
fade_len = 240

comp = []
for i in range(gap_len):
    if i < gap_len - fade_len:
        gain = 1.0
    else:
        gain = (gap_len - 1 - i) / (fade_len - 1)
    comp.append(int(round(prev[i % FRAME_SAMPLES] * gain)))

本机实际输出:

compensated: rms_err=3275.40 peak_err=20281 snr=12.41 dB
improvement: 76.0% (rms 13662.50 -> 3275.40)
lost seq=40 frame_rms_err=27.43
lost seq=41 frame_rms_err=52.20
lost seq=42 frame_rms_err=5672.86

RMS 误差从 13,662.50 降到 3,275.40,改善 76%,信噪比从 0 分贝提高到 12.41 分贝。前两帧的误差只有 27.43 和 52.20,几乎和原始信号重合;第三帧误差跳到 5,672.86,因为淡出把振幅压低了,而原始信号在这一段还在正常发声。

这个结果能这么好,有一个前提:测试信号是 400Hz 加 800Hz,两个频率在 480 个样本里都是整数个周期。重复前一帧时,相位刚好接得上,所以前 20 毫秒几乎完美。真实语音、音乐没有这个性质,重复帧会很快出现相位错位,实际改善会小很多。这一点必须说清楚,不能拿示例数字当通用承诺。

淡出长度也不是越长越好。把不同淡出长度都跑一遍,结果如下:

淡出长度RMS 误差信噪比结尾阶跃
0ms54.7447.94 dB1,720
2.5ms,120 样本2,379.8815.18 dB0
5ms,240 样本3,275.4012.41 dB0
10ms,480 样本4,594.619.47 dB0
30ms,1440 样本7,920.194.74 dB0

不淡出时,波形误差最小,RMS 只有 54.74,因为重复帧和原信号几乎一样;但结尾的阶跃是 1,720,足以听成一次「咔」。淡出 2.5 毫秒就能把阶跃压到 0,代价是误差升到 2,379.88。继续加长淡出,误差越来越大,因为淡出本身就是在把还没结束的声音强行拉低。

所以 5 毫秒是一个折中:阶跃已经消除,误差还在可接受范围。这个值不是标准答案,和帧长、内容、播放设备都有关系。语音可以用更短的淡出,音乐可能需要交叉淡入到下一帧,而不是单向淡出到零。

语音通话:优先保连续

30 毫秒的缺口用重复加短淡出就够了,听感上像一次轻微的含糊。语音对相位不敏感,重复帧不容易被察觉。

音乐播放:优先保节奏

重复整帧会让节奏错位,通常用更短的补偿,配合交叉淡入下一帧,或者直接静音,避免把上一拍拖长。

补偿不是修复,只是遮掩

必须把预期摆正:丢掉的样本不可能被「算」回来。补偿做的是让波形在缺口处听起来不那么突兀,不是恢复原始内容。任何 PLC 算法,包括业界常用的波形相似、基音预测、频谱延展,输出的都是近似值,不是真值。

传输层:FEC 前向纠错、重传、冗余包,目标是尽量别丢
抖动缓冲层:用缓冲吸收到达时间波动,给重传留时间窗口
解码层:按 seq 检测缺口,按 timestamp 计算缺口长度
补偿层:重复、淡出、交叉淡入,目标是听感连续而不是数值正确

四层里,补偿是最后一道,也是最无奈的一道。能重传就重传,能加冗余就加冗余,补偿只在实时性不允许等待时使用。直播场景里,如果每个包都等重传,延迟会越积越高;这时候宁可用补偿遮一下,也不要让整条流卡住。

补偿的长度要有上限。丢 30 毫秒可以遮,丢 300 毫秒还硬遮,就会变成一段循环的嗡嗡声,比静音更难听。常见做法是超过一定时长就淡出到静音,等下一帧到了再淡入,让听众感知到一次短暂的停顿,而不是一段伪造的内容。

判断补偿是否合格,不能只看波形图。把补偿段单独截出来循环播放,听它有没有周期性的「嗡」或者机械的重复感;再用频谱看有没有原来没有的谐波。波形相似不代表听感自然,耳朵对周期性重复比对齐误差更敏感。

不要把补偿后的样本写回文件或当作母版。补偿是播放时的临时遮掩,写回去会把错误固化,后面再分析、再转码都会带着这段假数据。原始文件要保留缺口信息,补偿只发生在播放链路。

边界与代价:什么时候该换策略

前帧重复加淡出实现简单,计算量几乎为零,适合资源紧张的嵌入式设备和低延迟通话。但它有明显边界:信号变化快时相位错位,音乐节奏会被拖长,连续丢包时重复内容会变成可辨认的循环。遇到这些情况,要换更复杂的策略,或者从传输层解决。

策略适用场景代价
补零只求不崩溃、能继续解析爆音、静音突兀,听感最差
前帧重复加淡出短缺口、语音、低延迟相位错位,音乐节奏失真
波形相似拼接周期性强的语音和乐器需要搜索最佳拼接点,计算量上升
基音预测浊音、元音较多的语音参数估计复杂,清音效果差
FEC 与重传有带宽余量、能容忍一点延迟占用额外带宽,重传增加延迟
加大抖动缓冲网络抖动大但丢包少端到端延迟增加,交互感变差

选择策略时,先量三件事:丢包率、连续丢包长度、端到端延迟预算。丢包率低但连续丢包长,优先加 FEC;丢包率随机且短,前帧补偿就够;延迟预算紧,不能等重传,只能接受一点遮掩。不要一上来就上最复杂的算法,先把缺口长度算准,很多问题在那一层就能定位。

还有一个代价是测试成本。丢帧补偿很难靠单元测试覆盖,必须用真实网络抓包、注入丢包、反复听。示例里只丢了固定的三帧,真实网络可能是随机单帧、连续多帧、乱序、重复混合出现。测试脚本要能控制这些变量,才能比较不同策略。

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

  1. 用上面的编码器生成 2 秒 SAUD 文件,核对文件大小是否等于 28 加 200 乘 976。
  2. 把丢帧序号改成 10、11,观察 10 毫秒缺口的补偿误差,再改成连续 10 帧对比。
  3. 把淡出长度从 0 改到 1440,记录 RMS 误差和结尾阶跃,画出你自己的取舍表。
  4. 故意把某一帧的 payload_len 改大,运行解码器,确认它会报错而不是读越界。
  5. 把测试信号换成频率随时间变化的 chirp,重跑补偿,比较它和 400Hz 固定信号的差别。

小结

三句话:SAUD 的编码器按 480 样本切片、写文件头和帧头,解码器逐帧校验长度和序号,未丢帧时可以逐样本无损还原;连续丢三帧会留下 30 毫秒缺口,补零的误差等于原信号,信噪比为 0 分贝;用前帧重复加 5 毫秒淡出,本例把 RMS 误差从 13,662.50 降到 3,275.40,改善 76%,但这只是遮掩,不是修复。

这组音频教程到这里告一段落。下一篇换个角度,讲音频工程里三个更隐蔽的坑:采集和播放的时钟不一致、长时间累积的漂移,以及重采样和缓冲怎么把这些问题放大。