2024年4月10日发(作者：)
…… …… … ……… … … ……………… ……………
实用第一 智慧密集
一 ．… 一 …
Ａ 厂Ｉ 播放器开发
洪
摘 要：使用ＸＶＩＤ编解码库ｘｖｉｄｃｏｒｅ．ｄＵ和微软的ｗｉｎｍｍ．１ｉｂ多媒体开发库中放音的相关函数，
以及ＬＡＭＥ库中的ＭＰ３解码函数，结合ＡＶＩ文件的结构，开发了可以实现ＡＶＩ文件播放功能的
实用程序。
关键词：ＸＶＩＤ；ＭＰ３；ＡＶＩ；ＬＡＭＥ；播放器
ＡＶＩ文件是Ｗｉｎｄｏｗｓ系统下一种很常见的视频文件，由微
软公司首先推出．用于保存图像和声音信息。其中的图像和声
音数据大都经过编码后进行存放。大部分媒体播放器都支持此
类文件的播放。下面将开发一个实用的ＡＶＩ文件播放器，可进
行ＡＶＩ视频文件的播放。
本播放器目前只支持ＡＶＩ文件。其中图像编码必须为
ＸＶＩＤ．声音编码必须为ＭＰ３，且图像帧速率应介于２０—３０之
间。其他编码暂不支持。
进行图像解码，需用到ｘｖｉｄｃｏｒｅ．ｄｌｌ这个动态链接库。这是
一
个开源的ＸＶＩＤ编码解码库，可以从ｗｗｗ．ｘｖｉｄ．ｏｒｇ下载该库
的源代码。
播放图像则使用Ｗｉｎｄｏｗｓ提供的图形设备对象。
进行声音解码，需用到ｌａｍｅ库，这是另一个开源的ＭＰ３
编码解码库，可从ｌａｍｅ．ｓｏｕｒｃｅｆｏｒｇｅ．ｎｅｔ下载。
播放声音则使用微软的ｗｉｎｍｍ．１ｉｂ这个多媒体开发库中的
声音播放函数。
１ ＡＶｌ文件结构
ＡＶＩ文件是微软公司推出的一种多媒体文件格式。该文件
通常包括一个视频流和一个音频流。
ＡＶＩ文件南一个ＲＩＦＦ头，两个列表ｈｄｒｌ（用于描述媒体
流格式）和ｍｏｖｉ列表（用于保存媒体流数据），以及一个可选
的索弓Ｉ块组成。
ｈｄｄ列表包括一个主信息头和两个ｓｔｒｌ子列表（分别用于
描述视频和音频流），其中主信息头结构如下：
ｔｙｐｅｄｅｆ ｓｔｒｕｃｔ ａｖｉｍａｉｎｈｅａｄｅｒ（
ＤＷＯＲＤ ｆｃｃ；／／必须为‘ａｖｉｈ’
ＤＷＯＲＤ ｃｂ：／／本数据结构的大小，不包括最初的８字节
ＤＷ０ＲＤ ｄｗＭｉｃｒｏＳｅｃＰｅｒＦｒａｍｅ；
∥视频帧间隔时间（以微秒为单位）
ＤＷＯＲＤ ｄｗＭａｘＢｙｔｅｓＰｅｒＳｅｃ；／／这个ＡＶＩ文件的最大数据率
ＤＷＯＲＤ ｄｗＰａｄｄｉｎｇＧｒａｎｕｌａｒｉｔｙ；／／数据填充的粒度
ＤＷＯＲＤ ｄｗＦｌａｇｓ；／／ＡＶＩ文件的全局标记，比如是否含有索引
９ 毫扁２０螭１１穗 ．蔽０９砖与壤 ｉ２；
｜ｆ块等
ＤＷＯＲＤ ｄｗＴｏｔａｔＦｒａｍｅｓ；／／总帧数
ＤＷＯＲＤ ｄｗｌｎｉｔｉａｌＦｒａｍｅｓ；／／为交互格式指定初始帧数
ＤＷＯＲＤ ｄｗＳｔｒｅａｍｓ；／／本文件包含的流的个数
ＤＷＯＲＤ ｄｗＳｕｇｇｅｓｔｅｄＢｕｆｆｅｒＳｉｚｅ；／／建议读取本文件的缓存
”大，＼＼
ＤＷＯＲＤ ｄｗＷｉｄｔｈ；／／视频图像的宽（以像素为单位）
ＤＷ０ＲＤ ｄｗＨｅｉｇｈｔ；／／视频图像的高（以像素为单位）
ＤＷＯＲＤ ｄｗＲｅｓｅｒｖｅｄ［４］；／／保留
１ ＡＶＩＭＡｌＮＨＥＡＤＥＲ；
视频流和音频流子列表中包括一些基本的视频和音频参
数．如编码格式、声道数、采样频率等。
ｍｏｖｉ列表中保存实际的视频和音频数据。其中视频和音
频数据都是交错存放的。视频数据以００ｄｃ开头，其后４个字
节是该块数据长度，然后是实际的视频数据。音频数据以
０１ｗｂ开头．其后４个字节是该块数据长度，然后是实际的音频
数据。
索引段以ｉｄｘｌ开头．用于保存ｍｏｖｉ列表中各块的索引信息。
２ ＬＡＭＥ库
开发利用ＬＡＭＥ库提供的ＡＰＩ进行ＭＰ３的解码。
ＬＡＭＥ库提供的解码部分ＡＰＩ如下：
进行ＭＰ３解码前执行ｌａｍｅ—ｄｅｃｏｄｅ—ｉｎｉｔＯ；
完成ＭＰ３解码后执行ｌａｍｅ—ｄｅｃｏｄｅ＿ｅｘｉｔ（）；
进行ＭＰ３解码使用函数为
ｓｉｚｅ＝ｌａｍｅ
—
ｄｅｃｏｄｅ（ｂｕｆ，ｒ，ｌｅｆｔｐｃｍ．ｒｉｇｈｔｐｃｍ）；
此函数中ｂｕｆ为ＭＰ３编码的数据，ｒ为ｂｕｒ的大小，完成解
码后数据放在ｌｅｆｔｐｃｍ和ｒｉｇｈｔｐｃｍ中，分别对应左右卢道的数
据，返回值为解码后的大小。
３微软多媒体开发库
微软提供了多媒体开发库，名为ｗｉｎｍｌＴ１．１ｉｂ，头文件名为
ｍｍｓｙｓｔｅｍ．ｈ。
这个库中ｗａｖｅＯｕｔ系列函数用于声音输出。
……
ＰＲＯＧＲＡＭ ＬＡＮＧ哪Ｂ …………………………………………………………………… … ……………… ・
ｔ
ｖｅ
ｒｓｉｏ
ｎ
ｎ
ｎ
ｔ
∥
ｔＶ
ｐｅ＝
４ Ｘｋ／ＩＤ编码解码库
ＸＶＩＤ库巾提供了数据的解码操作。
解码前首先调用ｘｖｉｄ
ｇｌｏｂａｌ（ＮＵＬＬ，ＸＶＩＤ—ＧＢＬＩＮＩＴ，
号
ｕ ｏｎｉ
ｉｎｔ ｇｅｎｅｒａＩ：∥通用标志
＆ｘｖｉｄ
ｇｂｌ＿ｉｎｉｔ，ＮＵＬＬ）；进行初始化。其中ＸＶＩＤ—ＧＢＬ＿ＩＮＩＴ表示
—
ｉｎｔ ｔｉｍｅｂａｓｅ：
ｉｎｔ ｔｉｍｅ
ｉｎｃｒｅｍｅｎｔ；
—
进行初始化。ｘｖｉｄ一＿ｇｂｌ ｉｎｉｔ是一个ｘｖｉｄ＿ｇｂ］＿ｉｎｉｋ—ｔ类型的变量，
该类型用于ＸＶＩＤ初始化。 ｉｎｔ ｑｓｃａｌｅ；
然后调用ｘ ｒｉｄ＿＿ｄｅｃ。ｒｅ（ＮＵＬＬ，．ＸＶＩＤ—ＤＥＣ—ＣＲＥＡＴＥ，＆ｘ、，ｉｄ—ｄ
ｅｃ
ｉｎｔ ｑｓｃａｌｅ＿ｓｔｒｉｄｅ；
． ．
ｃｒｅａ ＮｕＬＬ）；创建一个解码实例。其中ＸＶＩＤ～ＤＥｃ—ｃＲＦ＿ 。。ｐ：／／描述一个视频对象平面
ＡＴＥ表示创建解码实例。ｘｖｉｄ—ｄｅｃ—ｃｒｅａｔｅ是一个ｘｖｉｄ ｄｅｃ—ｃｒｅ—
ａｔｅ
—
ｔ类型的变量，该类型用于建立解码实例。如果
ｘｖｉｄ
ｄ，￣ｅＣ０１＂， 返回０，则可从ｘｖｉｄ—ｄ，ｅｃ
ｃｒｅａｔｅ中取得解码实例的
句柄。
ｘｖｉｄ ｄｅｃ ｃｒｅａｔｅ ｔ结构定义如下：
：ｙ
ｐｅｄｅｉ‘ ，ｔｒｕｃｔ
｛
．
．．．
…
Ｉｎｔ ｖｅｒｓｉｏｎ；／／股 丐
ｉｎｔ ｗｉｄｔｈ；∥图像宽度
ｉｎｔ ｈ 图
ｖｏｉｄ ｈａｎｄｌｅ；∥解码实例句柄
概
）Ｘｖｉｄ ｄｅｃ ｃｒｅａｔｅ ｔ：
调用ｘ、５ｄ．ｄｅｃｏｒｅ ｆｄｅｃ ｈａｎｄｌｅ．ＸＶＩＤ ＤＥＣ ＤＥＣＯＤＥ，
＆ｘｖｉｄｄｅｃ
ｆｒａｍｅ，＆ｘＶ
一
ｄｅｃ
ｓｔａｌｓ）；进行ＸＶＩＤ解码。该函
数通常在一个循环中被反复调用，直到解出实际的图像。
其中ＸＶＩＤ＿ＤＥ￣一ＤＥＣＯＤＥ表示进行ＸＶＩＤ解码。
ｘｖｉｄｄｅｃ
ｆｒａｍｅ是一个ｘｖｉｄ—ｄｅｃ ｆｒａｍｅ＿ｔ类型的变量，该类
型用于描述解出的帧。
ｘｖｉｄ
ｄｅｃ
ｆｒａｍｅ
＿ｔ定义如下：
ｔｙｐｅｄｅｆ ｓｔｒｕｃｔ（
ｉｎｔ ｖｅｒｓｉｏｎ；｜｜版苓号
ｉｎｔ ｇｅｎｅｒａｌ；／／：通用标志
ｖｏｉｄ ｂｉｔｓｔｒｅａｍ；／／输入缓冲区
ｉｎｔ ｌｅｎｇｔｈ；∥输入缓冲长度
ｘｖｉｄ
—
ｉｍａｇｅ ｔ ｏｕｔｐｕｔ；／／＠出图像
ｉｎｔ ｂｒｉｇｈｔｎｅｓｓ；
：ｔｘｖｉｄ ｄｅｃ ｆＹａｍｅ＿ｔ；
其中ｘｖｉｄ
ｊｍａｇｅ＿ｔ是另一个结构，表示输出图像，其定义
如下：
ｔｙｐｅｄｅｆ ｓｔｒｕｃｔｔ【
ｉｎｔ ｃｓｐ；／／使用的色场空间
ｖｏｉｄ ｐｌａｎｅ［４］；／／图像平面，最多４个，一般只使用ｐｌａｎｅ［Ｏ］
ｉｎｔ ｓｔｒｉｄｅ［４］；／／表示每行像素占用字节数
］￣ｘｖｉｄ—ｉｍａｇｅ—ｔ
ｘｖｉｄｄｅｃ
ｓｔａｔｓ是一个ｘｖｉｄ
ｄｅｃ
ｓｔａｔｓ
ｔ类型的变量，该类型
—
用于表示解码帧的状态。
ｘｖｉｄ ｄｅｃ ｓｔａｔｓ
ｔ定义如下
ｔｙｐｅｄｅｆ ｓｔｒｕｃｔｉ【
ｎｔ ｇｅｎｅｒａＩ：∥通用标志
ｉｎｔ ｗｉｄｔｈ；／／解码后宽度
ｉｎｔ ｈｅｉｇｈｔ；／／解码后高度
ｉｎｔ ｐａｒ；
ｉｎｔ ｐａｒ＿ｗｉｄｔｈ；
Ｎｏｌ；／／描述一个视频对象层
１ｄａｔａ．
） ｉｄ ｅｃ ｓｔａｔｓ ｔ：
ｉＮＮ—
ｘｖｉｄｄ
ｅｃ。
… 、…一……“ ……～
∽
ｈａｎ ，ｘｖＩＤ～ＤＥＣ—ＤＥＳＴＲ０Ｙ＇ＮｕＬＬ
一 …… … ’
ＮＵＬＬ）；结束一个解码实例。其中ｄｅｃ
ｈａｎｄｌｅ是先前得到的解
码实例句柄，ＸＶＩＤ
ＤＥＣ
ＤＥＳＴＲＯＹ表示撤销解码实例。
５ 程序代码
程序中定义如下全局变量
ＣＰｌａｙａｖｉＡｐｐ ｔｈｅＡｐｐ＝ｎｅｗ ＣＰｌａｙａｖｉＡｐｐ；／Ｄ立用程序指针
ｃｈａｒ ｆｆｉｌｅｎａｍｅ＝ｎｅｗ ｃｈａｒ［２５０］；Ｎ多媒体文件名
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｔｉｍｅｓｐａｎ；／／帧时间间隔 毫秒
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｔｏｔａｌｔｉｍｅ；／／，总播放时间
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｔｉｍｅｓｐａｎ１：／／帧时间间隔，微秒
ＨＡＮＤＬＥ ｈａ；Ｎ文件句柄，用于音频解码
ｕｎｓｉｇｎｅｄ ｓｈｏｒｔ ｃｈａｎｎｅｌ
ｃｏｕｎｔ；∥声道数
ＬＰＳＴＲ ｓｏｕｎｄｂｕｆｌ，ｓｏｕｎｄｂｕｆ２；／／声音缓冲区
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｓｏｕｎｄｌｅｎｌ＝Ｏ，ｓｏｕｎｄｌｅｎ２＝０；／／声音缓冲长度
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｓｔａｒｔｔｉｍｅ；／Ｌ声音开始播放时间
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ａｖｇｂｙｔｅｓｐｅｒｓｅｃ：／／每秒声音字节数
ｉｎｔ ｅｎｄｆｌａｇ；／／：声音结束标志
ｉｎｔ ｐｌａｙｉｎｇ；／／播放标志
ＨＷＡＶＥＯＵＴ ｈｗｏ；／／声音输出句柄
＼＾ｆ△ＶＥＨＤＲ ｗａｗｅｈｄｒ；／／：声音输出头
ＨＤＣ ｍｙｄｃ：∥图形设备对象句柄
ＣＤＣ ｄｃｌ＝ｎｅｗ ＣＤＣ；∥图形设备对象
ＣＤＣ ｄｃ２＝ｎｅｗ ＣＤＣ；Ｎ图形设备对象
ＨＡＮＤＬＥ ｈｖ；／／文件句柄，用于视频解码
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｓｈｏｗｗｉｄｔｈ ｓｈｏｗｈｅｉｇｈｔ：∥图像显示宽度，长度
ＤＷＯＲＤ ｓｔａｒｔｔｉｃｋ；／／图像开始时钟数
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｆｒａｍｅｎｕｍｂｅｒ；／／帧号
播放声音线程如下：
ＵＩＮＴ ＰｌａｖＡｕｄｉｏ《ＬＰＶＯＩＤ ｐＰａｒａｍ）∥播放声音线程
嘲 乌 、：９
……… … 一 ………… ”…” … ………… 一………
实用第一 智慧密集
， … …………… … … ～ … … … …… … ……
｛
ｕｎｓｉｇｎｅｄ ｃｈａｒ ｂｕｆ［２００００］，ｃｈｌ，ｃｈ２，ｃｈ３，ｃｈ４，ｐｃｍ１：
ＤＷＯＲＤ ＲｅａｄＣＯｕｎｔ＝０：
ｓｈｏｒｔ ｉｎｔ ｌｅｆｔｐｃｍ［１ ０００００］，ｒｉｇｈｔｐｃｍ［１ ０００００］；
ｕｎｓｉｇｎｅｄ ｉｎｔ ｉ：
ｕｎｓｉｇｎｅｄ ｓｈｏｒｔ ｃｈａｎｎｅｌｓ，ｃｏｄｅ，ｂｌｏｃｋａｌｉｇｎ；
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｌｅｎ，ｓｉｚｅ１，ａｕｄｌｅｎ，ｓａｍｐｌｅｒａｔｅ，ｂｙｔｅｓｐｅｒｓｅｃ，ｐｏｓ；
ＷＡＶＥＦＯＲＭＡＴＥＸ ｗｆｘ；
ｉｎｔ ｃｏｕｎｔ；
｜帆 文忤
ｈａ＝ＣｒｅａｔｅＦｉｌｅ（ｆｉｌｅｎａｍｅ，ＧＥＮＥＲＩＣ—ＲＥＡＤ．ＦＩＬＥ—ＳＨＡＲＥ—Ｒ
ＥＡＤ，ＮＵＬ ＬＪ
ＯＰＥＮ
ＥＸＩＳＴＩＮＧ，ＦＩＬＥ
一
△Ｌ１－ｒＲｌＢＵＴＥ
—
ＮＯＲＭＡＬ，ＮＵＬＬ）；
—
ｉｆ（ｈａ＝＝ｌＮＶＡＬＩＤ—ＨＡＮＤＬＥ＿ＶＡＬＵＥ）ｒｅｔｕｒｎ Ｏ：
ＲｅａｄＦｉｌｅ（ｈａ，ｂｕｆ，１００００，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；∥读一块数据
ｆｏｒ（ｉ＝１：ｉ＜：１ Ｏ０００；ｉ＋＋）／／定位ｍｏｖｉ列表
｛
ｉｆ（ｂｕｆ［ｉ一１】＿＝ ｍ ＆＆ｂｕｆ［ｉ】＿＝一０＆＆ｂｕｆ［ｉ＋ｌ】－＝＇Ｖ ＆＆ｂｕｆ ＋
２】＝＝ ）
｛
ｐｏｓ＝ｉ一１；ｂｒｅａｋ；
）
）
ｆｏｒ（ｉ＝１： ＜＝１ Ｏ０００；ｉ＋＋）
｛
ｉｆ（ｂｕｆ［ｉ一１ｌ＿：～Ｓ＆＆ｂｕｆ［ｉ】＿＝～ｔ＆＆ｂｕｆ［ｉ＋ｌ】＝＝ ｒ ＆＆ｂｕｆ［ｉ＋２】
＝＝
＆＆
ｂｕｆ【ｉ十３ ＝ Ｓ ＆＆ｂｕｆ【ｉ＋４】＝＝ ｔ ＆＆ｂｕ ＋５】＝＝ ｒ ＆＆ｂｕｆ【 十
６】＿＝ ｈ ＆＆
ｂｕｆ【ｉ＋１ １】＝＝ Ｖ ＆＆ｂｕｆ【ｉ＋１２】＝＝ ＆＆ｂｕｆ Ｉ ＋１３】＝＝
ｄ ＆＆ｂｕｆ［ｉ＋ｌ４】＿＝ Ｓ ）
（
ｍｅｍｃｐｙ（＆ａｕｄｌｅｎ，ｂｕｆ＋ｉ＋７，４）；ｂｒｅａｋ；
）
｝
ｆｏｒ（ｉ＝１：ｉ＜＝１ Ｏ０００；ｉ＋＋）／／取声音参数
｛
ｉｆ（ｂｕｆ［ｉ一１】＝＝ ｓ ＆＆ｂｕｆ【ｉ】＝＝ ｔ ＆＆ｂｕｆ［ｉ＋１】＝＝ ｒ ＆＆ｂｕｆ［ｉ＋２】
＝＝
＆＆
ｂｕｆ［ｉ＋３］＝＝ Ｓ ＆＆ｂｕｆ¨＋４】＝＝～ｔ＆＆ｂｕｆ［ｉ＋５】＝＝ ｒ ＆＆ｂｕｆ【 ＋
６】＿＝ ｈ ＆＆
ｂｕｆ【ｉ＋１１】＝＝ ａ ＆＆ｂｕｆ【ｉ＋１２】＝＝ Ｕ ＆＆ｂｕｆ【ｉ＋１３】＝＝
ｄ ＆＆ｂｕｆ［ｉ＋ｌ４】＿＝ Ｓ ＆＆
ｂｕｆ［ｉ＋ａｕｄｌｅｎ＋ｌ １】＝＝～Ｓ＆＆ｂｕｆ［ｉ＋ａｕｄｌｅｎ＋ｌ ２】＝＝ ｔ＆＆
ｂｕｆ［ｉ＋ａｕｄｌｅｎ＋ｌ ３】＝＝ ｒ ＆＆ｂｕｆ【ｉ＋ａｕｄＩｅｎ＋１ ４】＝＝ ｆ ）
｛
ｍｅｍｃｐｙ（＆ｃｏｄｅ，ｂｕｆ＋ｉ＋ａｕｄｌｅｎ＋ｌ ９，２）
ｍｅｍｃｐｙ（＆ｃｈａｎｎｅｌｓ．ｂｕｆ＋ｉ＋ａｕｄｌｅｎ＋２１，２）：
ｃｈａｎｎｅｌ
ｃＯｕｎｔ＝ｃｈａｎｎｅ｝ｓ：
ｍｅｍｃｐｙ（＆ｓａｍｐｌｅｒａｔｅ．ｂｕｆ＋ｉ＋ａｕｄｌｅｎ＋２３，４）；
ａｖｇｂｙｔｅｓｐｅｒｓｅｃ＝ｓａｍｐｌｅｒａｔｅ １ ６ ｃｈａｎｎｅｌ
＿
ｃｏｕｎｄ８；
ｂｒｅａＫ：
ｌ ｏ
ｉ
，
：电麓２０藉１１寝．交０９砖与娥 ｉ ；
｝
）
ｉｆ（ｃｏｄｅ！＝０ｘ５５）／／声音编码不为ＭＰ３则返回
｛
Ｃ｛ＯｓｅＨａｎｄＩｅ（ｈａ） ｒｅｔｕｍ ０：
）
ｓｔａｒｔｔｉｍｅ＝ＧｅｔＴｉｃｋＣｏｕｎｔＯ；
ｓｏｕｎｄｂｕｆｌ＝ｎｅｗ ｃｈａｒ【５Ｏ０ＯＯＯＯ０】：ｓＯｕｎｄｂｕｆ２＝ｎｅｗ ｃｈａｒ
【５０００００００］；
ｗａｖｅＯｕｔＵｎｐｒｅｐａｒｅＨｅａｄｅｒ《ｈｗｏ，＆ｗａｖｅｈｄｒ，ｓｉｚｅｏｆ（ＷＡＶＥ—
ＨＤＲ））：
ｗａｖｅ０ｕｔＣＩｏｓｅ（ｈｗｏ）；
ｓｏｕｎｄｌｅｎｌ＝Ｏ：ｓＯｕｎｄｌｅｎ２＝Ｏ：
ｌａｍｅ
—
ｄｅｃｏｄｅ
ｉｎｉｔＯ；∥开始声音解码
ＳｅｔＦ ｌｅＰｏｉｎｔｅｒ｛ｈａ，ｐｏｓ，ＮＵＬＬ，ＦＩＬＥ
—
ＢＥＧＩＮ）；
ｗｆｘ．ｃｂＳｉｚｅ＝Ｏ；
ｂｌｏｃｋａｌｉｇｎ＝ｌ ６ ｃｈａｎｎｅｌｓ／８；
／／设置声音文件头
ｗｆｘ．ｎＢＩＯｃｋＡＩｉｇｎ＝ｂ１０ｃｋａＩｉｇｎ：
ｂｙｔｅｓｐｅｒｓｅｃ＝ｂＩＯｃｋａＩｉｇｎ ｓａｍｐｌｅｒａｔｅ；
ｗｆｘ．ｎＡｖｇＢｙｔｅｓＰｅｒＳｅｃ＝ｂｙｔｅｓｐｅｒｓｅｃ：
ｗｆｘ．ｎＣｈａｎｎｅＩｓ＝ｃｈａｎｎｅＩｓ：
ｗｆｘ ｎＳａｍｐｌｅｓＰｅｒＳｅｃ＝ｓａｍｐｌｅｒａｔｅ；
ｗｆｘ．ｗＢｉｔｓＰｅｒＳａｍｐｌｅ＝ｌ ６：
ｗｆｘ．ｗＦｏｒｍａｔＴａｇ＝１：
ｆ 开声音输出
ｗａｖｅＯｕｔＯｐｅｎ（＆ｈｗｏ，《ＵＩＮＴ）Ｖ、／ＡＶＥ—ＭＡＰＰＥＲ，＆ｗｆｘ，
（ＤＷＯＲＤ）ｗａｖｅＯｕｔＣａｌｔｂａｃｋ，０，ＣＡＬＬＢＡＣＫ
ＦＵＮＣＴＩＯＮ）；
ｅｎｄｆｌａｇ＝Ｏ；
ｗｈｉｌｅ《１）
｛
ＲｅａｄＦｉｔｅ（ｈａ ＆ｃｈ１，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）：
ｉｆ（ＲｅａｄＣｏｕｎｔ！：１）ｂｒｅａｋ；
ｉｆ（ｃｈ１＝＝ ０ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ２，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ２＝＝ １ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ３＝＝ Ｗ ）
（
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ４，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ４＝＝ ｂ ）∥读出声音数据
｛
ＲｅａｄＦｉＩｅ（ｈａ，＆ｌｅｎ，４，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ＲｅａｄＦｉｌｅ（ｈａ，ｂｕｆ，ｌｅｎ，＆ＲｅａｄＣｏｕｎｔ．ＮＵＬＬ）：
ｓｉｚｅ１ ＝ｌａｍｅ
—
ｄｅｃｏｄｅ（ｂｕｆ，ｔｅｎ，ｌｅｆｔｐｃｍ，ｒｉｇｈｔ－
ｐｃｍ）：／／声音解码
ｉｆ《ｃｈａｎｎｅＩｓ＝＝２）
｛
ｆｏｒ（ｉ＝１；ｉ＜＝ｓｉｚｅｌ：ｉ＋＋）
｛
…
ＰＲＯＧＲＡＭ ＬＡＮＧＵＡＧＥ … ＋， 一 ……
ｐｃｍ ｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（１ｅｆｔｐｃｍ［ｉ一１】＆ＯｘＯＯＦＦ）；
ｓｏｕｎｄｂｕｆｌ Ｉｓｏｕｎｄｌｅｎ ｌ】＝ｐｃｍ ｌ：
ｐｃｍ１＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（１ｅｆｔｐｃｍ［ｉ－１】＞＞８）＆０×ＦＦ）：
ｓｏｕｎｄｂｕｆｌ【ｓｏｕｎｄｌｅｎｌ＋１】＝ｐｃｍｌ：
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（ｒｉｇｈｔｐｃｍ［ｉ－１】＆ＯｘＯＯＦＦ）；
ｓｏｕｎｄｂｕｆｌ ｌｓｏｕｎｄｌｅｎｌ＋２］＝ｐｃｍｌ：
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（ｒｉｇｈｔｐｃｍ［ｉ－１】＞＞８）＆ＯｘＦＦ）：
ｓｏｕｎｄｂｕｆｌ【ｓｏｕｎｄｌｅｎｌ＋３］＝ｐｃｍ１：
ｓｏｕｎｄｌｅｎ ｌ＝ｓｏｕｎｄｌｅｎ ｌ＋４：
｝
）
ｉｆ（ｃｈａｎｎｅｌｓ＝＝１）
（
ｆｏｒ（ｉ＝１；ｉ＜＝ｓｉｚｅｌ：；十＋）
（
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（１ｅｆｔｐｃｍ［ｉ－１】＆ＯｘＯＯＦＦ）；
ｓｏｕｎｄｂｕｆｌ Ｉｓｏｕｎｄｌｅｎ １】＝ｐｃｍ １：
ｐｃｍ１＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（１ｅｆｔｐｃｍ［ｉ－１ ｌ＞＞８）＆ＯｘＦＦ）：
ｓｏｕｎｄｂｕｆｌ【ｓｏｕｎｄｌｅｎ １＋１】＝ｐｃｍ １：
ｓｏｕｎｄｌｅｎ１＝ｓｏｕｎｄｌｅｎｌ＋２：
）
）
ｉｆ（ｓｏｕｎｄｌｅｎ １＞４０００００００）ｂｒｅａｋ；
｝
ｅｌｓｅ ＳｅｔＦｉＩｅＰＯｉｎｔｅｒ《ｈａ，一３Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
｝
ｅｌｓｅ ＳｅｔＦｉ『ｅＰＯｉｎｔｅｒ《ｈａ，一２Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
｝
ｅｌｓｅ ＳｅｔＦ；１ｅＰｏｉｎｔｅｒ（ｈａ，一１ Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｉｆ（ｃｈｌ＝＝ ）∥读到索引段则退出
｛
ＲｅａｄＦｉｌｅ（ｈａ ＆ｃｈ２，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｊｆ（ｃｈ２＝＝ ｄ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ３＝＝ Ｘ ）
（
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ４，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ４＝＝ １ ）ｂｒｅａｋ；
ｅｌｓｅ ＳｅｔＦｉｌｅＰｏｉｎｔｅｒ（ｈａ 一３Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦ 『ｅＰｏｉｎｔｅｒ（ｈａ，一２Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
｝
ｅｌｓｅ ＳｅｔＦｉ『ｅＰｏｉｎｔｅｒ（ｈａ，一１ Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
）
ｃｏｕｎｔ＝Ｏ；
ｗｈｉｌｅ（１）
｛
ｉｆ（ｃｏｕｎｔ％２＝＝Ｏ）
｛
． ． …， …一… “ 一 ， ， ．
ｉｆ（ｃｏｕｎｔ＝＝Ｏ）ｐｌａｙｉｎｇ＝ｌ：
“话嵌ｓｏｕｎｄｂｕｆｌ
ｗａｖｅＯｕｔＵｎｐｒｅｐａｒｅＨｅａｄｅｒ（ｈｗｏ，＆ｗａｖｅｈｄｒ，ｓｉｚｅｏｆ（ＷＡＶＥ—
ＨＤＲ））：
ｗａｖｅｈｄｒ．ＩｐＤａｔａ＝ＳＯｕｎｄｂｕｆ１：
ｗａｖｅｈｄｒ ｄｗＢｕｆｆｅｒＬｅｎｇｔｈ＝ｓｏｕｎｄｌｅｎ １—４０００；
ｗａｖｅｈｄｒ ｄｗＢｙｔｅｓＲｅｃｏｒｄｅｄ＝Ｏ；
ｗａｖｅｈｄｒ．ｄｗＵｓｅｒ＝Ｏ；ｗａｖｅｈｄｒ．ｄｗＦｌａｇｓ＝Ｏ；ｗａｖｅｈｄｒ．
ｄｗＬｏｏｐｓ＝Ｏ；
ｗａｖｅＯｕｔＰｒｅｐａｒｅＨｅａｄｅｒ《ｈｗｏ，＆ｗａｖｅｈｄｒ，ｓｉｚｅｏｆ（ＷＡＶＥ—
ＨＤＲ））：
ｗａｖｅＯｕｔＷｒｉｔｅ（ｈｗｏ，＆ｗａｖｅｈｄｒ，ｓｉｚｅｏｆ（ＷＡＶＥＨＤＲ））；
ｓｏｕｎｄｌｅｎ１＝０：
∥填充ｓｏｕｎｄｂｕｆ２
ｗｈｉｌｅ（”
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ１，１，＆ＲｅａｄＣｏｕｎｔ．ＮＵＬＬ）
ｆ（ＲｅａｄＣｏｕｎｔｌ＝１）
｛
ｐｆａｙｉｎｇ＝Ｏ：ｂｒｅａｋ
１
ｆ（ｃｈ１：＝ ０ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ ＆ｃｈ２ １ ＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ２＝＝ １ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ３＝＝ Ｗ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ４，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ４＝＝ ｂ ）
（
ＲｅａｄＦｉｌｅ（ｈａ，＆ｆｅｎ，４，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ＲｅａｄＦｉｌｅ（ｈａ，ｂｕｆ，『ｅｎ，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｓｉｚｅ１＝ｌａｍｅ
—
ｄｅｃｏｄｅ（ｂｕｆ，ｌｅｎ，ｌｅｆｔｐｃｍ，ｒｉｇｈｔｐｃｍ）；
／／声音解码
Ｉｆ（ｃｈａｎｎｅＩｓ＝＝２）
｛
ｆｏｒ（ｉ＝１；ｉ＜＝ｓｉｚｅ１：ｉ＋十）
｛
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（１ｅｆｔｐｃｍ［ｉ－１ １＆ＯｘＯＯＦＦ）；
ｓｏｕｎｄｂｕｆ２［ｓｏｕｎｄｌｅｎ２］＝ｐｃｍ１；
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（１ｅｆｔｐｃｍ［ｉ一１】＞＞８）＆ＯｘＦＦ）：
ｓｏｕｎｄｂｕｆ２ｌｓＯｕｎｄ１ｅｎ２＋１】＝ｐｃｍｌ：
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（ｒｉｇｈｔｐｃｍ［ｉ一１ Ｊ＆ＯｘＯＯＦＦ）；
ｓｏｕｎｄｂｕｆ２［ｓｏｕｎｄｌｅｎ２＋２］＝ｐｃｍ １；
ｐｃｍ１＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（ｒｉｇｈｔｐｃｍ［ｉ－１】＞＞８）＆０ｘＦＦ）
ｓｏｕｎｄｂｕｆ２［ｓｏｕｎｄｌｅｎ２＋３］＝ｐｃｍｌ：
ｓＯｕｎｄＩｅｎ２＝ｓＯｕｎｄｆｅｎ２＋４：
）
）
Ｉｆ（ｃｈａｎｎｅｌｓ＝＝１）
【 。， 一 ＩＡ Ｉ… 一 ‘ … ｕ ．
≈
实用第一 智慧密集
｛
ｆｏｒ（ｉ＝１；ｉ＜＝ｓｉｚｅｌ：ｊ十＋）
ｌ
ｐｃｍ ｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（１ｅｆｔｐｃｍ【ｉ一１ ｊ＆Ｏｘ０ＯＦＦ）
ｓｏｕｎｄｂｕｆ２［ｓｏｕｎｄｌｅｎ２］＝ｐｃｍｌ：
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（Ｉｅｆｔｐｃｍ【ｉ一１】＞＞８）＆ＯｘＦＦ）：
ｓｏｕｎｄｂｕｆ２【ｓｏｕｎｄｌｅｎ２＋１】＝ｐｃｍｌ；
ｓＯｕｎｄｌｅｎ２＝ｓＯｕｎｄＩｅｎ２＋２：
｝
）
ｉｆ《ｓＯｕｎｄＩｅｎ２＞４０ＯＯＯＯ０Ｏ）ｂｒｅａｋ；
）
ｅｌｓｅ ＳｅｔＦｉｌｅＰｏｉｎｔｅｒ（ｈａ，一３Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦｉＩｅＰｏｉｎｔｅｒ（ｈａ，一２Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦ ｌｅＰＯｉｎｔｅｒ（ｈａ，一１ Ｌ，ＮＵＬＬ，ＦＩＬＥ
＿
ＣＵＲＲＥＮＴ）；
）
ｉｆ（ｃｈ１＝＝ ）∥读到索引段则退出
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ２，１．＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｆ（ｃｈ２＝＝ ｄ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ３＝＝ Ｘ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ４ １，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）：
ｉｆ（ｃｈ４＝＝ １ ）ｂｒｅａｋ；
ｅｌｓｅ ＳｅｔＦ ＩｅＰｏ ｎｔｅ ｈａ，一３Ｌ ＮＵＬＬ，ＦＩＬＥ
—
ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦｉ１ｅＰｏｉｎｔｅｒ｛ｈａ，一２Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦｉＩｅＰ０ｉｎｔｅｒ（ｈａ，一１ Ｌ，ＮＵＬＬ，ＦＩＬＥ
—
ＣＵＲＲＥＮＴ）；
）
）
）
ｅｌｓｅ
（
ｆ｝播设ｓｏｕｎｄｂｕｆ２
ｗａｖｅＯｕｔＵｎｐｒｅｐａｒｅＨｅａｄｅｒ（ｈｗｏ，＆ｗａｖｅｈｄｒ，ｓｉｚｅｏｆ（ＷＡＶＥ
ＨＤＲ））：
ｗａｖｅｈｄｒ．１ＤＤａｔａ ｓＯｕｎｄｂｕ｛２：
ｗａｖｅｈｄｒ．ｄｗＢｕｆｆｅｒＬｅｎｇｔｈ＝ｓｏｕｎｄｌｅｎ２－４０００；
ｗａｖｅｈｄｒ．ｄｗＢｙｔｅｓＲｅｃＯｒｄｅｄ＝Ｏ
ｗａｖｅｈｄｒ ｄｗＵｓｅｒ＝Ｏ；ｗａｖｅｈｄｒ．ｄｗＦｌａｇｓ＝Ｏ；ｗａｖｅｈｄｒ．
ｄｗＬｏｏｐｓ＝Ｏ；
ｗａｖｅＯｕｔＰｒｅｐａｒｅＨｅａｄｅｒ （ｈｗｏ，＆ｗａｖｅｈｄｒ，ｓｉｚｅｏｆ（ＷＡＶＥ
ＨＤＲ））
ｗａｖｅＯｕｔＷｒｉｔｅ（ｈｗｏ，＆ｗａｖｅｈｄｒ，ｓｉｚｅｏｆ（ＷＡＶＥＨＤＲ））；
ｓＯｕｎｄｌｅｎ２＝０：
／＃８充ｓｏｕｎｄｂｕｆｌ
ｗｈｉｌｅ（１）
。１２ ２电脑缡毽技巧与 ０１１．Ｏｇ 壤
（
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈｌ，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ＲｅａｄＣｏｕｎｔ！＝１ １
（
ｐｌａｙｉｎｇ＝Ｏ：ｂｒｅａｋ：
）
ｆ（ｃｈｌ：＝ ０ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ．＆ｃｈ２，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ２＝＝ １ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ３＝＝ Ｗ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ４，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ４＝＝ ｂ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｔｅｎ，４，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）：
ＲｅａｄＦｉｌｅ（ｈａ，ｂｕｆ，ｌｅｎ，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｓｉｚｅ１＝ｌａｍｅ
ｄｅｃｏｄｅ（ｂｕｆ，ｌｅｎ．１ｅｆｔｐｃｍ，ｒｉｇｈｔｐｃｍ）
／／声音解码
ｉｆ（ｃｈａｎｎｅ１ｓ＝＝２）
｛
ｆｏｒ（ｉ＝１；ｉ＜＝ｓｉｚｅｌ： ＋＋）
（
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（１ｅｆｔｐｃｍ［ｉ一１】＆ＯｘＯＯＦＦ）；
ｓｏｕｎｄｂｕｆｌ【ｓｏｕｎｄｌｅｎｌ】＝ｐｃｍ１：
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（１ｅｆｔｐｃｍ［ｉ－１】＞＞８）＆ＯｘＦＦ）：
ｓｏｕｎｄｂｕｆｌｆｓｏｕｎｄｌｅｎｌ ４－１】＝ｐｃｍ１
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（ｒｉｇｈｔｐｃｍ［ｉ－１】＆ＯｘＯＯＦＦ）
ｓｏｕｎｄｂｕｆｌ【ｓｏｕｎｄｌｅｎｌ＋２｝＝ｐｃｍｌ：
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（ｒｉｇｈｔｐｃｍ［ｉ一１】＞＞８）＆０ｘＦＦ）：
ｓｏｕｎｄｂｕｆｌ【ｓｏｕｎｄｌｅｎｌ＋３］＝ｐｃｍ１：
ｓｏｕｎｄｌｅｎ １＝ｓｏｕｎｄｌｅｎ １＋４：
｝
）
ｉｆ（ｃｈａｎｎｅｌｓ＝＝１）
｛
ｆｏｒ（Ｊ＝１；ｉ＜＝ｓｉｚｅｌ：ｊ＋＋）
｛
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（１ｅｆｔｐｃｍ［ｉ－１】＆ＯｘＯＯＦＦ）；
ｓｏｕｎｄｂｕｆｌ【ｓｏｕｎｄｌｅｎｌ ｌ＝ｐｃｍｌ
ｐｃｍｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ）（（１ｅｆｔｐｃｍ［ｉ一１】＞＞８）＆０ｘＦＦ）：
ｓｏｕｎｄｂｕｆｌｆｓｏｕｎｄｌｅｎ１＋１】＝ｐｃｍｌ
ｓｏｕｎｄｌｅｎ１＝ｓｏｕｎｄｌｅｎｌ＋２：
）
）
ｉｆ（ｓｏｕｎｄｌｅｎｌ＞４０００００００）ｂｒｅａｋ；
｝
ｅｌｓｅ ＳｅｔＦｉＩｅＰｏ ｎｔｅｒ（ｈａ，一３Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
｝
ｅｌｓｅ ＳｅｔＦｉＩｅＰｏｉｎｔｅｒ（ｈａ，一２Ｌ，ＮＵＬＬ，ＦＩＬＥ
—
ＣＵＲＲＥＮＴ）；
．
ＰＲ０ＧＢ＾Ｍ ＬＡＮＧＵＡＧＥ … ……一…一一一……… …………… … ～－ ………～……………－．一一…………＋．１ ＾ｕｖ ｈ¨ … ……
）
ｅｌｓｅ ＳｅｔＦｉ１ｅＰｏｉｎｔｅｒ（ｈａ，一１ Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｉｆ（ｃｈ１－＝ ）∥读到索引段则退出
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ２，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ２＝＝ ｄ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）
ｉｆ（ｃｈ３＝＝ Ｘ ）
｛
ＲｅａｄＦｉｌｅ（ｈａ，＆ｃｈ４，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ４＝＝ １ ）ｂｒｅａｋ；
ｅｌｓｅ ＳｅｔＦｉＩｅＰＯｉｎｔｅｒ《ｈａ，～３Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦｉｌｅＰｏｉｎｔｅｒ（ｈａ，一２Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
｝
ｅｌｓｅ ＳｅｔＦｊＩｅＰｏｉｎｔｅｒ（ｈａ，一１ Ｌ，ＮＵＬＬ．ＦＩＬＥ～ＣＵＲＲＥＮＴ）
｝
）
）
ｅｎｄｆｌａｇ＝０；∥设置声音结束标志
ｃｏｕｎｔ＋＋
ｗｈｉｌｅ（１）∥循环直至声音播放结束
｛
ｉｆ（ｅｎｄｆｌａｇ＝＝１）ｂｒｅａｋ；
Ｓｌｅｅｐ（１）：
）
ｉｆ（ｐｌａｙｉｎｇ＝＝０）ｂｒｅａｋ；
｝
ｌａｍｅ
—
ｄｅｃｏｄｅ
—
ｅｘｉｔ（）；／／结束声音解码
ｄｅｌｅｔｅ ｓｏｕｎｄｂｕｆｌ；ｄｅｌｅｔｅ ｓｏｕｎｄｂｕｆ２；
ｗａｖｅＯｕｔＣＩｏｓｅ（ｈｗｏ）；
Ｃ１０ｓｅＨａｎｄＩｅ（ｈａ）：∥关闭文件
ｒｅｔｔｊｒｎ ０－
）
视频播放线程女Ｉ】下：
ＵＩＮＴ ＰＩａｖＶｉｄｅＯ（ＬＰＶ０ＩＤ ｐＰａｒａｍ）
∥播放图像线程
（
ＨｌＮＳＴＡＮＣＥ ｈＨａｎｄｌｅ；
ｔｙｐｅｄｅｆ ｉｎｔ 《 Ｔｘｖｉｄ—ｇｌｏｂａ１）
《ｖｏｉｄ ｈａｎｄｌｅ，ｉｎｔ ｏｐｔ，ｖｏｉｄ
ｐａｒａｍ １，ｖｏｉｄ ｐａｒａｍ２）；
Ｔｘｖｉｄ ｇｌｏｂａＩ ｘｖｉｄ
．
ｇｌｏｂａ
ｌ：
ｔｙｐｅｄｅｆ ｉｎｔ （ Ｔｘｖｉｄ—ｄｅｃｏｒｅ）（ｖｏｉｄ ｈａｎｄｌｅ，ｉｎｔ ｏｐｔ，ｖｏｉｄ
ｐａｒａｍ１ ｖｏｉｄ ｐａｒａｍ２）
Ｔｘｖｉｄｄｅｃｏｒｅ ｘｖｉｄ
——
ｄｅｃｏｒｅ；
——
ｘｖｉｄ ｇｂＩ ｉｎｉｔ ｔ ｘｖｉｄ ｇｂ Ｊｉｎｉｔ；
ｘｖｉｄ
——
ｄｅｃ
ｃｒｅａｔｅ
ｔ ｘｖｉｄ
ｄｅｃ
——
ｃｒｅａｔｅ；
ｖｏｉｄ ｄｅｃ ｈａｎｄｌｅ＝ＮＵＬＬ；
ｘｖｉｄ
—
ｄｅｃｆｒａｍｅｔ ｘｖｉｄ
—
ｄｅｃ
—
ｆｒａｍｅ：
ｘｖｉｄ ｄｅｃ ｓｔａｔｓ ｔ ｘｖｉｄ ｄｅｃ ｓｔａｔｓ：
ｕｎｓｉｇｎｅｄ ｃｈａｒ ｃｈｌ，ｃｈ２，ｃｈ３，ｃｈ４， ｂｕｆ＝ＮＵＬＬ， ｂｕｆｌ＝ＮＵＬＬ，
ｂｕｆ２［１ ００００］；
ＬＰＳＴＲ ｂｕｆ３；
ＤＷ０ＲＤ ＲｅａｄＣＯｕｎｔ＝０．ＷｒｉｔｅＣｏｕｎｔ＝Ｏ；
ｕｎｓｉｇｎｅｄ ｌｏｎｇ ｆｉｌｅｓｉｚｅ，ｉｍｇｓｉｚｅ，ｏｆｆｓｅｔ，ｕｓｅｄ
—
ｂｙｔｅｓ，ｕｓｅ
ｆｕｌ
ｂｙｔｅｓ；
ｕｎｓｉｇｎｅｄ ｔｏｎｇ ｌｅｎ，ｗｉｄｔｈ，ｈｅｉｇｈｔ，ｉ．ｔｏｔａｌｔｉｍｅ，ｆｒａｍｅｓｐｅｒｓｅｃ．
ｐｏｓ，ｔｏｔａｌｆｒａｍｅｓ；
ＬＯＮＧＬＯＮＧ ｎｕｍｂｅｒ．ｎｕｍｂｅｒ１：
ＣＳｔｒｉｎｇ ｓｔｒ；
ＨＢＩＴＭＡＰ ｈｂｍｐ；
ＣＢｉｔｍａｐ ｈｂｍｐｌ， ｐＯＩｄＢｉｔｍａｐ；
ＢＩＴＭＡＰ ｂｍ；
ＬＡＲＧＥｌＮＴＥＧＥＲ ｆｒｅｑ，ｆｒｅｑｌ，ｔｌ，ｔ２，ｔ３；
ＣＳｔａｔｉｃ ｓｔａｔｉｃ２． ｓｔａｔｉｃ３；
ｃｈａｒ ｓ［１ ０Ｏ】：
ｓｔａｔｉｃ２＝（ＣＳｔａｔｉｃ ）ＡｆｘＧｅｔＭａｉｎＷｎｄ ０－＞ＧｅｔＤＩｇｌｔｅｍ
（ＩＤＣ—ＳＴＡＴＩＣ２）：
ｓｔａｔｉｃ３＝（ＣＳｔａｔｉｃ ）ＡｆｘＧｅｔＭａｉｎＷｎｄ ０一＞ＧｅｔＤＩｇｌｔｅｍ
（ＩＤＣ
—
ＳＴＡＴＩＣ３）；
ｈｖ＝ＣｒｅａｔｅＦｉｌｅ（ｆｉｌｅｎａｍｅ．ＧＥＮＥＲＩＣ—ＲＥＡＤ．ＦＩＬＥ—ＳＨＡＲＥ—ＲＥＡ
Ｄ，ＮＵＬＬ，
ＯＰＥＮ ＥＸＩＳＴＩＮＧ．ＦＩＬＥ Ａ‘丌ＲＩＢＵＴＥ Ｎ０Ｒ—
ＭＡＬ．ＮＵＬＬ）；｝ｍ开文件
ｉｆ（ｈｖ＝＝ＩＮＶＡＬＩＤ—ＨＡＮＤＬＥ＿、，ＡＬＵＥ）ｒｅｔｕｒｎ Ｏ：
ＲｅａｄＦｉｔｅ（ｈｖ，ｂｕｆ２，１００００，＆ＲｅａｄＣｏｕｎｔ ＮＵＬＬ）；／／读一块数据
ｆｏｒ（ｉ＝１：ｉ＜＝１ ００００；ｉ＋＋）
｛
ｉｆ（ｂｕｆ２ Ｉ 一１】＝＝ ｍ ＆＆ｂｕｆ２Ⅲ＝＝ ｏ ＆＆ｂｕｒ２ Ｉｉ＋１】＝＝
Ｖ ＆＆ｂｕｆ２【ｉ＋２】一＝丁）
（
ｐｏｓ＝ｉ一１；ｂｒｅａｋ；
）
）
ｆｏｒ（ｉ＝１：ｉ＜＝１００００；ｉ＋＋）／／保证图像编码是×ＶｌＤ
（
ｆ（ｂｕｆ２【ｉ一１】＝＝ Ｓ ＆＆ｂｕｆ２【＿】＝＝ ｔ ＆＆ｂｕｆ２【 ＋１ｊ＿＝ ｒ ＆＆ｂｕｆ２
ｆｉ＋２】＿＝ ＆＆
ｂｕｆ２【ｉ＋３］＝＝ Ｓ ＆＆ｂｕｆ２ ｆｉ＋４】＝＝ ｔ ＆＆ｂｕｆ２【ｉ＋５】＝＝
ｒ ＆＆ｂｕｆ２【ｉ＋６】＿＝ ｈ ＆＆
ｂｕｆ２【ｉ＋１ １】＝＝～ ＆＆ｂｕｆ２ ｆｉ＋１２】＝＝ ＆＆ｂｕｆ２【ｉ＋１３】＝＝
ｄ ＆＆ｂｕｆ２［ｉ＋ｌ ４】＝＝ Ｓ ）
｛
ｆ（ｆ（ｂｕｆ２［ｉ＋ｌ５】＝＝，× ＆＆ｂｕｆ２【 ＋１６】＝＝ Ｖ ＆＆ｂｕｆ２［ｉ＋１７ｌ＝＝
＆＆ｂｕｆ２［ｉ＋ｌ ８】＝＝ Ｄ，））
（
ＣＩｏｓｅＨａｎｄｌｅ（ｈｖ）：ｒｅｔｕｒｎ ０：
｝
）
）
ｆｏｒ（ｉ＝１： ＜：１ Ｏ０００；ｉ＋＋）脓图像参数
｛
ｉｆ（ｂｕｆ２ｌｉ一１】＿＝ ａ ＆＆ｂｕｆ２［ｉ］＝＝ Ｖ ＆＆ｂｕｆ２［ｉ＋１】＝＝ ＆＆ｂｕｆ２［ｉ＋
；
９ 煞缡趣２掘０涵１１乌．０ｉ蠹９ １３ｊ
… …… … ……………
实用第一 智慧密集
２Ｊ＝＝ ｈ ）
｛
ｍｅｍｃｐｙ（＆ｔｏｔａｌｆｒａｍｅｓ，ｂｕｆ２＋ｉ＋２３，４）
ｍｅｍｃｐｙ（＆ｔｉｍｅｓｐａｎ，ｂｕｆ２＋ｉ＋７ ４）：
ｔｌｍｅｓｐａｎ１＝ｔｉｍｅｓｐａｎ；
ｔｏｔａｌｔｉｍｅ＝ｔｉｍｅｓｐａｎ ｔｏｔａｌｆｒａｍｅｓ／１ Ｏ０００００Ｌ；
ｔｉｍｅｓｐａｎ＝ｔｉｍｅｓｐａｎ／１ ０００；
ｆｒａｍｅｓｐｅｒｓｅｃ＝ｌ Ｏ００Ａｉｍｅｓｐａｎ；
ｉｆ（ｆｒａｍｅｓｐｅｒｓｅｃ＜２ＯＩＩｆｒａｍｅｓｐｅｒｓｅｃ＞３０）
∥保证帧速率在２Ｏ一３０之间
｛
ＣＩｏｓｅＨａｎｄＩｅ（ｈｖ）；ｒｅｔｕｒｎ ０；
）
ｓｔｒ＝ＣｏｎｖｅｒｔＴｉｍｅ（ｔｏｔａｌｔｉｍｅ）；
ｍｅｍｃｐｙ（＆ｗｉｄｔｈ，ｂｕｆ２＋ｉ＋３９，４）：
ｍｅｍｃｐｙ（＆ｈｅｉｇｈｔ，ｂｕｆ２＋ｉ＋４３，４）：
ｂｒｅａｋ；
）
）
ｈＨａｎｄｌｅ＝ＬｏａｄＬｉｂｒａｒｙ（”ｘｖｉｄｃｏｒｅ．ｄｌｔ”） ／／力日载动态库
ｘｖｉｄ
—
ｇｌｏｂａｌ＝（Ｔｘｖｉｄ
＿
ｇｌｏｂａｔ）ＧｅｔＰｒｏｃＡｄｄｒｅｓｓ（ｈＨａｎｄｌｅ，“
ｘｖｉｄ
ｇｌｏｂａｌ ）：
ｘｖｉｄ
—
ｄｅｃｏｒｅ ＝（Ｔｘｖｉｄ
—
ｄｅｃ０ｒｅ）ＧｅｔＰｒｏｃＡｄｄｒｅｓｓ （ｈＨａｎｄｌｅ，
ｘｖｉｄ ｄｅｃｏｒｅ“）：
ｍｅｍｓｅｔ（＆ｘｖｉｄ
ｇｂｌ
ｉｎｉｔ ０，ｓｉｚｅｏｆ（ｘｖｉｄ
ｇｂｌ
——
ｉｎｉｔ
＿
ｔ））；
ｘｖｉｄ
——
ｇｂｌ
——
ｉｎｉｔ．ｖｅｒｓｉｏｎ＝ＸＶＩＤ
＿
ＶＥＲＳＩＯＮ；
ｘｖｉｄ
——
ｇｂｌ
——
ｉｎｉｔ．ｃｐｕ
ｆｌａｇｓ＝Ｏ；
ｘｖｉｄ
ｇｂｌｉｎｉｔ．ｄｅｂｕｇ＝Ｏ；
ｘｖｉｄ
——
ｇｌｏｂａｌ（ＮＵＬＬ，ＸＶｌＤ
—
ＧＢＬ
＋
ＩＮＩＴ，＆ｘｖｉｄ
——
ｇｂｌ
——
ｉｎｉｔ，ＮＵＬＬ）；
／／解码初始化
ｍｅｍｓｅｔ（＆ｘｖｉｄ
ｄｅｃ
ｃｒｅａｔｅ，０，ｓｉｚｅｏｆ（ｘｖｉｄ
ｄｅｃ
—
ｃｒｅａｔｅ
＿
ｔ））
ｘｖｉｄ
＿
ｄｅｃ
．
ｃｒｅａｔｅ ｖｅｒｓｉｏｎ＝ＸＶＩＤ
——
ＶＥＲＳＩＯＮ；
ｘｖｉｄ
——
ｄｅｃ
——
ｃｒｅａｔｅ．ｗｉｄｔｈ＝Ｏ；
ｘｖｉｄ
——
ｄｅｃ
——
ｃｒｅａｔｅ．ｈｅｉｇｈｔ＝Ｏ；
ｉｆ（ｘｖｉｄ—ｄｅｃｏｒｅ（ＮＵＬＬ，ＸＶｌＤ—ＤＥＣ—ＣＲＥＡＴＥ，＆ｘｖｉｄ
—
ｄｅｃ
—
ｃｒｅａｔｅ，
ＮＵＬＬ）＝＝０）
ｄｅｃ
ｈａｎｄｌｅ＝ｘｖｉｄｄｅｃ
ｃｒｅａｔｅ．ｈａｎｄｌｅ；／／创建解码实例
ｂｕｆ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ ）ｍａｌｌｏｃ（５００００００）；
ｂｕｆｌ＝（ｕｎｓｉｇｎｅｄ ｃｈａｒ ）ｍａｌｌｏｃ（５００００００）；
ｂｕｆ３＝ｎｅｗ ｃｈａ ｒ【５ＯＯＯＯＯＯ】：
ＳｅｔＦｉｌｅＰｏｉｎｔｅｒ（ｈｖ，Ｏ，ＮＵＬＬ，ＦＩＬＥ
—
ＢＥＧＩＮ）：
ｍｅｍｓｅｔ（＆ｘｖｉｄ
ｄｅｃ
ｆｒａｍｅ，０，ｓｉｚｅｏｆ（ｘｖｉｄ
ｄｅｃｆｒａｍｅ
ｔ））；
ｍｅｍｓｅｔ（＆ｘｖｉｄ——ｄｅｃ——ｓｔａｔｓ，０，ｓｉｚｅｏｆ（ｘｖｉｄ ｄｅｃ ｓｔａｔｓ
＿
ｔ））；
ｘｖｉｄ
——
ｄｅｃ
——
ｆｒａｍｅ．ｖｅｒｓｉｏｎ＝ＸＶＩＤ
ＶＥＲＳＩＯＮ；
＿
ｘｖｉｄ
—
ｄｅｃ
—
ｓｔａｔｓ．ｖｅｒｓｉｏｎ＝×ＶＩＤ
ＶＥＲＳ１０Ｎ：
ｘｖｉｄ
——
ｄｅｃ
＿
ｆｒａｍｅ．ｇｅｎｅｒａｌ＝Ｏ；
ｘｖｉｄ
—
ｄｅｃ
—
ｆｒａｍｅ．ｏｕｔｐｕｔ．ｐｔａｎｅ［Ｏ］＝ｂｕｆｌ：
ｘｖｉｄｄｅｃ
＿
ｆｒａｍｅ．ｏｕｔｐｕｔ．ｓｔｒｉｄｅｉＯ］＝ｗｉｄｔｈ ３：
ｘｖｉｄ
—
ｄｅｃ
＿
ｆｒａｍｅ．ｏｕｔｐｕｔｃｓｐ＝ＸＶｌＤ
—
ＣＳＰ
—
ＢＧＲｌＸＶＩＤ—ＣＳＰ＿ＶＦＬＩ Ｐ＝
Ｓｅｔ ｅＰｏ＿ｎｔｅｒ（ｈｖ，ｐｏｓ，ＮＵＬＬ，ＦＩＬＥ
—
ＢＥＧＩＮ）；
ｆｒａｍｅｎｕｍｂｅｒ＝Ｏ；
ｗｈｉｌｅ（１）
１４
、０
电魅螭褪技巧与
２Ｏ１ １．Ｏ９
维鹣
｛
ＲｅａｄＦｉｌｅ（ｈｖ，＆ｃｈｌ，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ＲｅａｄＣｏｕｎｔ！＝１）ｂｒｅａｋ；
ｉｆ（ｃｈｌ＝＝ ０ ）
｛
ＲｅａｄＦｉｌｅ（ｈｖ，＆ｃｈ２，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ２＝＝ ０ ）
｛
ＲｅａｄＦｉｌｅ（ｈｖ，＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ３＝＝ ｄ ）
｛
ＲｅａｄＦｉｌｅ（ｈｖ，＆ｃｈ４，１，＆ＲｅａｄＣｏｕｎｔ ＮＵＬＬ）；
ｉｆ（ｃｈ４＝＝ Ｃ ）
（
ＲｅａｄＦｉｌｅ（ｈｖ，＆ｌｅｎ，４，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（１ｅｎ＞＝Ｏ）
｛
ＲｅａｄＦｉｌｅ（ｈｖ，ｂｕｆ，ｌｅｎ，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｕｓｅｆｕｌ
—
ｂｙｔｅｓ＝ｌｅｎ；
ｕｓｅｄ
ｂｙｔｅｓ＝Ｏ；
ｄｏ／／循环解码图像
｛
ｘｖｉｄ
——
ｄｅｃ
＿
ｆｒａｍｅ．ｂｉｔｓｔｒｅａｍ＝ｂｕｆ＋ｕｓｅｄ
——
ｂｙｔｅｓ；
ｘｖｉｄ
—
ｄｅｃｆｒａｍｅ．１ｅｎｇｔｈ＝ｕｓｅｆｕｌ
＿——
ｂｙｔｅｓ；
ｕｓｅｄｂｙｔｅｓ ＝ｘｖｉｄ
ｄｅｃｏｒｅ （ｄｅｃ
ｈａｎｄｌｅ
ＸＶＩ Ｄ
——
ＤＥＣ
——
ＤＥＣＯＤＥ，
＆ｘｖｉｄ
ｄｅｃ
＿
ｆｒａｍｅ．＆ｘｖｉｄ
ｄｅｃ
ｓｔａｔｓ）；
ｕｓｅｆｕｌｂｙｔｅｓ＝ｕｓｅｆｕｌｂｙｔｅｓ－ｕｓｅｄｂｙｔｅｓ；
｝
ｗｈｉｔｅ（ｘｖｉｄ
—
ｄｅｃ
—
ｓｔａｔｓ．ｔｙｐｅ＜＝０＆＆ｕｓｅｄ
ｂｙｔｅｓ＞Ｏ）；
ｉｆ（ｆｒａｍｅｎｕｍｂｅｒ＝＝Ｏ）
｛
ｗｈｉｌｅ（１）
｛
ｉｆ（ｐｌａｙｉｎｇ＝＝１）ｂｒｅａｋ；
Ｓｌｅｅｐ（１）：
）
ＱｕｅｒｙＰｅｒｆｏｒｍａｎｃｅＣｏｕｎｔｅｒ（＆ｔ１）
）
ｆｒａｍｅｎｕｍｂｅｒ＋＋；
，／保证每帧在指定时间显示
ＱｕｅｒｙＰｅｒｆｏｒｍａｎｃｅＦｒｅｑｕｅｎｃｙ（＆ｆｒｅｑ）；
ＱｕｅｒｙＰｅｒｆｏｒｍａｎｃｅＣｏｕｎｔｅｒ（＆ｔ２）；
ｎｕｍｂｅｒ＝（ＬＯＮＧ ＬＯＮＧ｝（（（ｄｏｕｂｌｅ）ｔ２．Ｑｕａｄ—
Ｐａｒｔ一（ｄｏｕｂｌｅ）ｔ１．ＱｕａｄＰａｒｔ）／
（ｄｏｕｂｌｅ）ｆｒｅｑ ＱｕａｄＰａ￣ （ｄｏｕｂｌｅ）ｌ ００００００）；
ｎｕｍｂｅｒ＝ｎｕｍｂｅｒ／ｔｉｍｅｓｐａｎｌ；
ｉｆ（ｎｕｍｂｅｒ＜ｆｒａｍｅｎｕｍｂｅｒ）
｛
ｗｈｉｌｅ（１）
ｆ
ＱｕｅｒｙＰｅｒｆｏｒｍａｎｃｅＦｒｅｑｕｅｎｃｙ（＆ｆｒｅｑ１）：
……
ＰＲＯＧＲＡ啊ＬＡＮＧＵＡＧＥ…”……………………………………… ………………… ……………¨ ｌ… … ………
ＱｕｅｒｙＰｅｒｆｏｒｍａｎｃｅＣｏｕｎｔｅｒ（＆ｔ３）；
ｎｕｍｂｅｒ１ ＝（ＬＯＮＧＬ０ＮＧ）（（（ｄｏｕｂｌｅ）ｔ３．
ＱｕａｄＰａｒｔ一（ｄｏｕｂｌｅ）ｔ１．ＱｕａｄＰａｒｔ）／
（ｄｏｕｂｌｅ）ｆｒｅｑ１．ＱｕａｄＰａｒｔ （ｄｏｕｂｌｅ）１ ００００００）；
ｎｕｍｂｅｒ１＝ｎｕｍｂｅｒ１／ｔｉｍｅｓｐａｎ１：
ｉｆ（ｎｕｍｂｅｒｌ＞＝ｆｒａｍｅｎｕｍｂｅｒ）ｂｒｅａｋ；
Ｓｌｅｅｐ（１）：
）
ｉｆ（ｎｕｍｂｅｒ１＞ｆｒａｍｅｎｕｍｂｅｒ）ｃｏｎｔｉｎｕｅ；
）
ｅｌｓｅ ｃｏｎｔｉｎｕｅ；
ｉｆ（ｆｒａｍｅｎｕｍｂｅｒ＝＝１）ｓｔａｒｔｔｉｃｋ＝ｔｉｍｅＧｅｔＴｉｍｅＯ；
ｉｆ（（ｆｒａｍｅｎｕｍｂｅｒ一１）％ｆｒａｍｅｓｐｅｒｓｅｃ＝＝Ｏ）
｛
ｓｔａｔｉｃ２一＞ＳｅｔＷｉｎｄｏｗＴｅｘｔ（“当前时间：“
＋ＣｏｎｖｅｒｔＴｉｍｅ（（ｔｉｍｅＧｅｔＴｉｍｅＯ—ｓｔａｒｔｔｉｃｋ）／１ Ｏ０Ｏ））：
ｓｐｒｉｎｔｆ（ｓ，＂当前帧：％ ，ｆｒａｍｅｎｕｍｂｅｒ一１）：
ｓｔａｔｉｃ３一＞ＳｅｔＷｉｎｄｏｗＴｅｘｔ（ｓ）；
｝
ｉｆ（ｘｖｉｄ—ｄｅｃ—ｓｔａｔｓ．ｔｙｐｅ＞Ｏ）∥解出图像
｛
ｍｅｍｓｅｔ（ｂｕｆ３，０，５４＋ｗｉｄｔｈ ｈｅｉｇｈｔ ３）：
ｉｍｇｓｉｚｅ＝ｗｉｄｔｈ ｈｅｉｇｈｔ ３
ｆｉｌｅｓｉｚｅ＝５４Ｌ＋ｉｍｇｓｉｚｅ；
ｏｆｆｓｅｔ＝５４；
ｂｕｆ３［Ｏ］＝ Ｂ ；ｂｕｆ３［１】＿ Ｍ ：
ｍｅｍｃｐｙ（ｂｕｆ３＋２，＆ｆｉｌｅｓｉｚｅ，４）：
ｆｏｒ（ｉ＝１：ｉ＜＝４：ｉ＋＋）ｂｕｆ３［５＋ｉ］＝Ｏ；
ｍｅｍｃｐｙ（ｂｕｆ３＋１ ０，＆ｏｆｆｓｅｔ，４）：
ｂｕｆ３［１ ４】＿０×２８：ｂｕｆ３Ｉ１ ５］＝Ｏ；ｂｕｆ３［１ ６］＝Ｏ；ｂｕｆ３［１ ７】＝Ｏ：
ｍｅｍｃｐｙ（ｂｕｆ３＋ｌ ８，＆ｗｉｄｔｈ，４）：
ｍｅｍｃｐｙ（ｂｕｆ３＋２２ ＆ｈｅｉｇｈｔ，４）：
ｂｕｆ３１２６］＝１；ｂｕｆ３１２７］＝Ｏ：
ｂ ３
ｂ
１８ ；ｂｕ ｆ３ １２ ９］ ＝ Ｏ
；
ｕｆ３【３Ｏ１＝０：ｂｕｆ３【３１１＝Ｏ：ｂｕｆ３【
．
。
３２１＝０：
．
ｂｕｆ
３【
。
３３ｌ
。
＝０：
ｍｅｍｃｐｙ（ｂｕｆ３＋３４，＆ ｍｇｓｉｚｅ，４）
ｆｏｒ（ｉ：１：ｉ＜：１６：ｌ＋十）ｂｕｆ３１３７＋ｉ］＝Ｏ：
ｍｅｍｃｐｙ（ｂｕｆ３＋５４，ｂｕｆｌ，ｗｉｄｔｈ ｈｅｉｇｈｔ ３）：
ｈｂｍｐ＝ＭｅｍｏｒｙＴｏＢｍｐ（ｂｕｆ３）；
ｈｂｍｐｌ—Ａｔｔａｃｈ（ｈｂｍｐ）：
ｐＯＩｄＢｉｔｍａｐ＝（
ｈｂｍｐ１．
ＣＢｉ
ＧｅｔＢｉ
ｔｍａｐ＊）
ｔｍａｐ（
ｄｃ１一＞ＳｅＩ
＆ｂｍ）；
ｅｃｔＯｂｊｅｃｔ（ｈｂｍｐ１）：
ｄｃ２－＞ＳｔｒｅｔｃｈＢＩｔ（Ｏ，０，ｓｈｏｗｗｉｄｔｈ，ｓｈｏｗｈｅｉｇｈｔ，
ｄｃ１，０，０，ｂｍ．ｂｍＷｉｄｔｈ，ｂｍ．ｂｍＨｅｉｇｈｔ，ＳＲＣＣＯＰＹ）；
ｄｃｌ一＞ＳｅｌｅｃｔＯ ｂｊｅｃｔ（＆ｐ０ｌｄＢｉｔｍａｐ）：
ＤｅｌｅｔｅＯｂｊｅｃｔ（ｈｂｍｐ１）；
ＤｅＩ ｅ
Ｏｂｊｅｃｔ｛ｈｂｍｐ）：
、
，
）
｝
ｅｌｓｅ ＳｅｔＦｉＩｅＰｏｉｎｔｅｒ（ｈｖ，一３Ｌ．ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮ Ｔ）；
｝
ｅｌｓｅ ＳｅｔＦｉｌｅＰｏｉｎｔｅｒ（ｈｖ．一２Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦｌＩｅＰＯｉｎｔｅｒ（ｈｖ，一１ Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｉｆ（ｃｈｌ＝＝ ｉ ）／／读到索引段则退出
｛
ＲｅａｄＦｉｌｅ（ｈｖ，＆ｃｈ２，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ２＝＝～ｄ）
｛
ＲｅａｄＦｉｌｅ｛ｈｖ ＆ｃｈ３，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ３＝＝ × ）
｛
ＲｅａｄＦｉｌｅ（ｈｖ，＆ｃｈ４，１，＆ＲｅａｄＣｏｕｎｔ，ＮＵＬＬ）；
ｉｆ（ｃｈ４＝＝ １ ）ｂｒｅａｋ；
ｅｌｓｅ ＳｅｔＦ¨ｅＰｏｉｎｔｅｒ（ｈｖ，一３Ｌ．ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ Ｓｅｔ ｅＰｏｉｎｔｅｒ（ｈｖ，－２Ｌ，ＮＵＬＬ，ＦＩＬＥ—ＣＵＲＲＥＮＴ）；
）
ｅｌｓｅ ＳｅｔＦｉｌｅＰｏｉｎｔｅｒ（ｈｖ，一１ Ｌ，ＮＵＬＬ，ＦＩＬＥ
ＣＵＲＲＥＮＴ）；
｝
）
ｓｔａｔｉｃ２一＞ＳｅｔＷｉｎｄｏｗＴｅｘｔ（”当前时间：”
＋ＣｏｎｖｅｒｔＴｉｍｅ（（ｔｉｍｅＧｅｔＴｉｍｅＯ—ｓｔａｒｔｔｉｃｋ）／１ Ｏ００））：
ｓｐｒｉｎｔｆ（ｓ，＂当前帧：％ ｆｒａｍｅｎｕｍｂｅｒ）；
ｓｔａｔｉｃ３—．＞ＳｅｔＷｉｎｄｏｗＴｅｘｔ（ｓ）；
ｆｒｅｅ《ｂｕｆ）：ｆｒｅｅ《ｂｕｆ１）；ｄｅｌｅｔｅ ｂｕｆ３；
ｘｖｉｄ—ｄｅｃｏｒｅ （ｄｅｃ—ｈａｎｄｌｅ，ＸＶｌＤ
—
ＤＥＣ
—
ＤＥＳＴＲＯＹ，ＮＵＬＬ，
ＮＵＬＬ）；／／结束解码实例
ＣＩｏｓｅＨａｎｄ｛ｅ（ｈｖ）：／／关闭文件
ｒｅｔｕｒｎ Ｏ：
）
现在声音
、
图像解码和输出都介绍完了，另外还有一个重
要问题
，
就是影音同步问题。因为ＡＶＩ文件中不仅包含图像，
同时也包含声音，所以必须考虑图像和声音的同步。
……… ’ ………… … … “…
声音播放时间可以交给声卡控制，只要能在一块声音播放
完成之前解码出下一块声音数据，再迅速切换声音输出即可。
图像播放时间则要利用精确计时函数，计算｝ｆＪ当前时间应
该播放的帧号
，
当实际帧号小于应该播放帧号时，则等待，直
到二者相等时进行显示
，
而当实际帧号大于应该播放帧＝ｂ ａｔ，，
应立即取消该帧的显示并立即进行下一帧的解码。
．
硅｛五
Ｄ 口Ｉ＝ｉ
ＡＶＩ播放器程序开发完成，可以进行ＡＶＩ多媒体文件的播
放
．
具有一定的实用价值。
（收稿日期
：２０１１－０３－１１）
发布评论