音频格式之WAV

        WAV是基于RIFF结构的音频文件，是微软为windows系统开发的一种标准音频文件格式。如PCM中介绍，粗略的可以理解为wav数据就是加了wav头的pcm数据，实际WAV文件由RIFF chunk、Format chunk 和 Data chunk三个主要区块组成。辅以fact、cue与list chunk。

一、WAV格式概要

┌─────────────────────────────────────────────────────────────────┐
│ WAV 文件结构 │
├─────────────────────────────────────────────────────────────────┤
│ RIFF Header │
│ ┌─────────────┬─────────────┬─────────────┐ │
│ │ Chunk ID │ Chunk Size │ Format │ │
│ │ "RIFF" │ 4 bytes │ "WAVE" │ │
│ │ 4 bytes │ (小端序) │ 4 bytes │ │
│ └─────────────┴─────────────┴─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Chunk 1 (fmt 、XMA2 等) │
│ ┌─────────────┬─────────────┬─────────────┐ │
│ │ Chunk ID │ Chunk Size │ Chunk Data │ │
│ │ 4 bytes │ 4 bytes │ N bytes │ │
│ └─────────────┴─────────────┴─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ Chunk 2 (data 等) │
│ ┌─────────────┬─────────────┬─────────────┐ │
│ │ Chunk ID │ Chunk Size │ Chunk Data │ │
│ │ 4 bytes │ 4 bytes │ N bytes │ │
│ └─────────────┴─────────────┴─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ … 更多 Chunk … │
└─────────────────────────────────────────────────────────────────┘

常规主要trunk

RIFF RIFF chunk：主要说明本文件保持的音频格式； Formt chunk：主要说明音频格式的相关属性，如采样率、采用位数等信息； Data chunk：主要记录实际的音频数据和长度信息；

大部分的都以以上三个trunk块组成，

辅助chunk

 不过wav还有fact、cue与list 等其他辅助trunk：

 注意： 整个chunk除标识字符（RIFF、WAVE、fmt和data）外，都是小端计算。

二、RIFF chunk

2.1 结构介绍

RIFFchunk结构分为3个子块，chunk id、chunk size和chunk format。

2.2

2.2 示例：

        如上图为许嵩-有何不可的wav文件，根据以上结构，解析出

问

文件大小 =  42,788,792 +8 = 42,788,800 字节， 如文件的实际大小一致，见下图的“大小”

三、Formt（fmt） chunk

3.1 结构介绍

上表中的format和size 对应下表的format和size

3.2 示例

 由以上可以看到，当前wav格式的

编码格式为：PCM

声道数为：双声道

采样率为：44100 HZ

对齐位位：4字节 

采用位数为：16 bit

比特率= 176400 b/s  *8 = 176.4 KB/s‌ * 8 = 1411.2 kbps ≈ 1411 kbps

以上信息与播放器解析的一致，如下图

四、Data chunk

4.1 结构介绍

4.2 示例

、

五、 list chunk

LIST chunk
┌─────────────┬─────────────┬─────────────┬─────────────┐
│ "LIST" │ Size │ Type │ Sub-chunks │
│ 4 bytes │ 4 bytes │ 4 bytes │ N bytes │
└─────────────┴─────────────┴─────────────┴─────────────┘

5.1 info 子chunk

LIST chunk
┌─────────────┬─────────────┬─────────────┬─────────────────────────────┐
│ "LIST" │ Size │ "INFO" │ 子块序列 │
│ 4 bytes │ 4 bytes │ 4 bytes │ │
└─────────────┴─────────────┴─────────────┴─────────────────────────────┘
│
▼
┌───────────────────────────────────────┐
│ 子块1 │ 子块2 │ … │ 子块N │
│ (IART) │ (INAM) │ │ (ICOP) │
└───────────────────────────────────────┘

每个子块结构：
┌─────────────┬─────────────┬─────────────┐
│ Chunk Code │ Chunk Size │ Chunk Data │
│ 4 bytes │ 4 bytes │ N bytes │
└─────────────┴─────────────┴─────────────┘

5.2 adt1 子chunk

adtl（Audio Data List） 是 RIFF LIST chunk 的子类型，用于存储章节标签名称。它与 cue chunk 配合使用：

WAV 文件中的章节信息组织
┌─────────────────────────────────────────────────────────┐
│ cue chunk │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Chapter 1: id=1, offset=10000 │ │
│ │ Chapter 2: id=2, offset=20000 │ │
│ └───────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────┤
│ LIST chunk (adtl) │
│ ┌───────────────────────────────────────────────────┐ │
│ │ labl: id=1, label="Chapter 1: Introduction" │ │
│ │ labl: id=2, label="Chapter 2: Main Content" │ │
│ └───────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
│
▼
┌───────────────────────┐
│ 最终章节元数据 │
│ Chapter 1: │
│ id=1 │
│ offset=10000 │
│ title="Chapter 1…"│
└───────────────────────┘

六、其它chunk

6.1  fact chunk

文件总采样率，可用用于计算播放整个音频文件所需的时间。

┌─────────────────────┬─────────────────┬─────────────────────┐
│ 字段名 │ 大小 (字节) │ 说明 │
├─────────────────────┼─────────────────┼─────────────────────┤
│ ID │ 4 │ 固定“fact”
│ size │ 4 │ trunk大小
│ SampleCount │ 4 │ 总采样数 │
└─────────────────────┴─────────────────┴─────────────────────┘

6.2 bext chunk

BEXT Chunk 的作用：

bext chunk 结构（BWF Version 1）
┌─────────────────────────────────────────────────────────┐
│ Chunk ID │ "bext" │ 4 bytes │
│ Chunk Size │ 可变长度 │ 4 bytes │
├─────────────────────────────────────────────────────────┤
│ description │ 文件描述 │ 256 bytes │
│ originator │ 创建者 │ 32 bytes │
│ originator_reference │ 创建者参考编号 │ 32 bytes │
│ origination_date │ 创建日期 │ 10 bytes (YYYY-MM-DD) │
│ origination_time │ 创建时间 │ 8 bytes (HH:MM:SS) │
│ time_reference │ 时间参考 │ 8 bytes (采样数) │
│ version │ BWF 版本 │ 2 bytes │
│ UMID │ 唯一物料标识 │ 64 bytes (可选) │
│ reserved │ 保留字段 │ 190 bytes │
│ coding_history │ 编码历史 │ 可变长度 (可选) │
└─────────────────────────────────────────────────────────┘

6.3 ID3 chunk

ID3 chunk 结构
┌─────────────┬─────────────┬─────────────────────────────┐
│ Chunk ID │ Chunk Size │ ID3v2 Tag Data │
│ "ID3 " │ 4 bytes │ 可变长度 │
│ 4 bytes │ (小端序) │ │
└─────────────┴─────────────┴─────────────────────────────┘

ID3的格式可以具体参考相关ID3介绍，此处不做赘述。

6.4 cue chunk

Cue chunk 结构
┌─────────────┬─────────────┬─────────────────────────────┐
│ Chunk ID │ Chunk Size │ Number of Cues │
│ "cue " │ 4 bytes │ 4 bytes │
│ 4 bytes │ (小端序) │ │
├───────────────────────────────────────────────────────────┤
│ Cue Point 1 │
│ ┌─────────────┬─────────────┬─────────────────────────┐ │
│ │ Cue ID │ Position │ Chunk ID │ │
│ │ 4 bytes │ 4 bytes │ 4 bytes │ │
│ ├─────────────┼─────────────┼─────────────────────────┤ │
│ │ Chunk Start │ Block Start │ Sample Offset │ │
│ │ 4 bytes │ 4 bytes │ 4 bytes │ │
│ └─────────────┴─────────────┴─────────────────────────┘ │
├───────────────────────────────────────────────────────────┤
│ Cue Point 2 … │
└───────────────────────────────────────────────────────────┘

6.5 XMA2 chunk

XMA2 chunk 结构
┌─────────────┬─────────────┬─────────────────────────────┐
│ Chunk ID │ Chunk Size │ XMA2 Configuration Data │
│ "XMA2" │ 4 bytes │ 可变长度 │
│ 4 bytes │ (小端序) │ │
└─────────────┴─────────────┴─────────────────────────────┘

编解码器特性

6.6 SMV0 chunk

SMV0 chunk 结构
┌─────────────┬─────────────┬─────────────────────────────┐
│ Chunk ID │ Chunk Size │ SMV Configuration │
│ "SMV0" │ 4 bytes │ 版本号 + 视频参数 │
│ 4 bytes │ (小端序) │ │
└─────────────┴─────────────┴─────────────────────────────┘

SMV 格式特点

七、ffmpeg解码源码

截取ffmpeg解码源码

for (;;) {
AVStream *vst;
size = next_tag(pb, &tag, wav->rifx);
next_tag_ofs = avio_tell(pb) + size;

if (avio_feof(pb))
break;

switch (tag) {
case MKTAG('f', 'm', 't', ' '):
/* only parse the first 'fmt ' tag found */
if (!got_xma2 && !got_fmt && (ret = wav_parse_fmt_tag(s, size, st)) < 0) {
return ret;
} else if (got_fmt)
av_log(s, AV_LOG_WARNING, "found more than one 'fmt ' tag\\n");

got_fmt = 1;
break;
case MKTAG('X', 'M', 'A', '2'):
/* only parse the first 'XMA2' tag found */
if (!got_fmt && !got_xma2 && (ret = wav_parse_xma2_tag(s, size, st)) < 0) {
return ret;
} else if (got_xma2)
av_log(s, AV_LOG_WARNING, "found more than one 'XMA2' tag\\n");

got_xma2 = 1;
break;
case MKTAG('d', 'a', 't', 'a'):
if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) && !got_fmt && !got_xma2) {
av_log(s, AV_LOG_ERROR,
"found no 'fmt ' tag before the 'data' tag\\n");
return AVERROR_INVALIDDATA;
}

if (rf64 || bw64) {
next_tag_ofs = wav->data_end = av_sat_add64(avio_tell(pb), data_size);
} else if (size != 0xFFFFFFFF) {
data_size = size;
next_tag_ofs = wav->data_end = size ? next_tag_ofs : INT64_MAX;
} else {
av_log(s, AV_LOG_WARNING, "Ignoring maximum wav data size, "
"file may be invalid\\n");
data_size = 0;
next_tag_ofs = wav->data_end = INT64_MAX;
}

data_ofs = avio_tell(pb);

/* don't look for footer metadata if we can't seek or if we don't
* know where the data tag ends
*/
if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || (!(rf64 && !bw64) && !size))
goto break_loop;
break;
case MKTAG('f', 'a', 'c', 't'):
if (!sample_count)
sample_count = (!wav->rifx ? avio_rl32(pb) : avio_rb32(pb));
break;
case MKTAG('b', 'e', 'x', 't'):
if ((ret = wav_parse_bext_tag(s, size)) < 0)
return ret;
break;
case MKTAG('S','M','V','0'):
if (!got_fmt) {
av_log(s, AV_LOG_ERROR, "found no 'fmt ' tag before the 'SMV0' tag\\n");
return AVERROR_INVALIDDATA;
}
// SMV file, a wav file with video appended.
if (size != MKTAG('0','2','0','0')) {
av_log(s, AV_LOG_ERROR, "Unknown SMV version found\\n");
goto break_loop;
}
av_log(s, AV_LOG_DEBUG, "Found SMV data\\n");
wav->smv_given_first = 0;
vst = avformat_new_stream(s, NULL);
if (!vst)
return AVERROR(ENOMEM);
wav->vst = vst;
avio_r8(pb);
vst->id = 1;
vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
vst->codecpar->codec_id = AV_CODEC_ID_SMVJPEG;
vst->codecpar->width = avio_rl24(pb);
vst->codecpar->height = avio_rl24(pb);
if ((ret = ff_alloc_extradata(vst->codecpar, 4)) < 0) {
av_log(s, AV_LOG_ERROR, "Could not allocate extradata.\\n");
return ret;
}
size = avio_rl24(pb);
wav->smv_data_ofs = avio_tell(pb) + (size – 5) * 3;
avio_rl24(pb);
wav->smv_block_size = avio_rl24(pb);
if (!wav->smv_block_size)
return AVERROR_INVALIDDATA;
avpriv_set_pts_info(vst, 32, 1, avio_rl24(pb));
vst->duration = avio_rl24(pb);
avio_rl24(pb);
avio_rl24(pb);
wav->smv_frames_per_jpeg = avio_rl24(pb);
if (wav->smv_frames_per_jpeg > 65536) {
av_log(s, AV_LOG_ERROR, "too many frames per jpeg\\n");
return AVERROR_INVALIDDATA;
}
AV_WL32(vst->codecpar->extradata, wav->smv_frames_per_jpeg);
goto break_loop;
case MKTAG('L', 'I', 'S', 'T'):
case MKTAG('l', 'i', 's', 't'):
if (size < 4) {
av_log(s, AV_LOG_ERROR, "too short LIST tag\\n");
return AVERROR_INVALIDDATA;
}
switch (avio_rl32(pb)) {
case MKTAG('I', 'N', 'F', 'O'):
ff_read_riff_info(s, size – 4);
break;
case MKTAG('a', 'd', 't', 'l'):
if (s->nb_chapters > 0) {
while (avio_tell(pb) < next_tag_ofs &&
!avio_feof(pb)) {
char cue_label[512];
unsigned id, sub_size;

if (avio_rl32(pb) != MKTAG('l', 'a', 'b', 'l'))
break;

sub_size = avio_rl32(pb);
if (sub_size < 5)
break;
id = avio_rl32(pb);
avio_get_str(pb, sub_size – 4, cue_label, sizeof(cue_label));
avio_skip(pb, avio_tell(pb) & 1);

for (int i = 0; i < s->nb_chapters; i++) {
if (s->chapters[i]->id == id) {
av_dict_set(&s->chapters[i]->metadata, "title", cue_label, 0);
break;
}
}
}
}
break;
}
break;
case MKTAG('I', 'D', '3', ' '):
case MKTAG('i', 'd', '3', ' '): {
ID3v2ExtraMeta *id3v2_extra_meta;
ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
if (id3v2_extra_meta) {
ff_id3v2_parse_apic(s, id3v2_extra_meta);
ff_id3v2_parse_chapters(s, id3v2_extra_meta);
ff_id3v2_parse_priv(s, id3v2_extra_meta);
}
ff_id3v2_free_extra_meta(&id3v2_extra_meta);
}
break;
case MKTAG('c', 'u', 'e', ' '):
if (size >= 4 && got_fmt && st->codecpar->sample_rate > 0) {
AVRational tb = {1, st->codecpar->sample_rate};
unsigned nb_cues = avio_rl32(pb);

if (size >= nb_cues * 24LL + 4LL) {
for (int i = 0; i < nb_cues; i++) {
unsigned offset, id = avio_rl32(pb);

if (avio_feof(pb))
return AVERROR_INVALIDDATA;

avio_skip(pb, 16);
offset = avio_rl32(pb);

if (!avpriv_new_chapter(s, id, tb, offset, AV_NOPTS_VALUE, NULL))
return AVERROR(ENOMEM);
}
}
}
break;
}

/* seek to next tag unless we know that we'll run into EOF */
if ((avio_size(pb) > 0 && next_tag_ofs >= avio_size(pb)) ||
wav_seek_tag(wav, pb, next_tag_ofs, SEEK_SET) < 0) {
break;
}
}