对于多媒体资源，一般都是以文件的形式存储在固化存储器中。Fatfs所支持的fat32为windows支持的文件系统，因此在嵌入式系统中采用Fatfs文件系统可极大地扩展系统的应用。例如，把计算机上图片，音频，视频，文本等资源直接拷贝到嵌入式系统中的固化存储器中，在系统中即可直接应用这些资源。把嵌入式系统中录制的音频、视频直接保存成一定的格式，在计算机上可直接播放处理，把传感器采集的数据保存成txt或dat文件，在计算机上通过处理生成数据曲线分析等。笔者此处就wav音频文件的播放与录音进行简单的介绍。

1. wav音频格式

Wave是录音时用的标准windows文件格式，文件扩展名为”.wav”，数据本身的格式为PCM或压缩型，它是由微软与IBM联合开发的用于音频数字存储的标准，采用RIFF文件格式结构。

RIFF全称资源互换文件格式，是windows下大部分多媒体文件遵循的一种文件结构，除了本文所说的波形格式数据(.wav)，采用RIFF格式结构的文件还有音频视频交错格式(.avi)、位图格式(.rdi)、MIDI格式(.rmi)、调色板格式(.pal)、多媒体电影(.rmn)、动画光标(.ani)。

RIFF结构的基本单元为chunk，它的结构如下：

  1. struct  chunk {
  3. unsignedint  id; /*  块标志 */
  5. unsignedint  size; /* 块大小 */
  7. unsigned chardata[size]; /* 块内容 */
  9. }

Id为4个ascii字符组成，用来识别块中所包含的数据，如”RIFF”、”WAV ”、”data”、”fmt ”等；size是存储在data域中数据的长度，不包括id与size域的大小；data[size]为该块保存的数据，以字为单位排列。

wav音频文件作为RIFF结构，其由若干个chunk组成，按照在文件中的位置包括：RIFF chunk，fmt chunk，fact chunk(可选)，data chunk。所有RIFF结构文件均会首先包含RIFF chunk，并指明RIFF类型，此处为”WAVE”。对于wav文件，在fmt chunk中指明音频文件的信息，例如采样位数、采样频率、声道数、编码方式等。对于压缩型wav音频，还会有一个fact chunk，用以指明解压后音频数据的大小，对于PCM非压缩wav文件，并没有该chunk。音频数据保存在data chunk中，根据fmt chunk中指明的声道数以及采样位数，wav音频数据存放形式有不同的方式。

一个PCM格式的wav结构定义Wav.h如下：

  1. #ifndef __WAV_H__
  3. #define __WAV_H__
  5. #ifdef __cplusplus
  7. extern "C" {
  9. #endif
  11. //资源互换文件格式RIFF，树状结构，基本单位是chunk，整个文件由chunk构成
  13. typedef struct RIFF_HEADER {
  15.     char Riff_ID[4];
  17.     unsigned int Riff_Size;//记录整个RIFF文件的大小，除ID和Size这两个变量
  19.     char Riff_Format[4];
  21. } RIFF_HEADER;
  25. typedef struct WAVE_FORMAT {
  27.     unsigned short FormatTag; //声音的格式代号
  29.     unsigned short Channels; //声音通道
  31.     unsigned int SamplesPerSec; //采样率
  33.     unsigned int AvgBytesPerSec; //=采样率*区块对其单位
  35.     unsigned short BlockAlign; //区块对其单位=每个取样所需位数*声音通道/8
  37.     unsigned short BitsPerSample; //每个取样所需位数
  39. } WAVE_FORMAT;
  43. typedef struct FMT_CHUNK {
  45.     char Fmt_ID[4];
  47.     unsigned int Fmt_Size;//记录fmt的大小
  49.     WAVE_FORMAT WaveFormat;
  51. } FMT_CHUNK;
  55. typedef struct DATA_CHUNK {
  57.     char Data_ID[4];
  59.     unsigned int Data_Size;//记录data区的大小
  61. } DATA_CHUNK;
  65. typedef struct WAVE_HEADER {
  67.     RIFF_HEADER   RiffHeader;
  69.     FMT_CHUNK   FmtChunk;
  71.     DATA_CHUNK  DataChunk;
  73. } WAVE_HEADER;
  77. #ifdef __cplusplus
  79. }
  81. #endif
  83. #endif /*__WAV_H__*/

根据以上的wav结构定义，一个录音文件的wav文件头可如下定义：

  1. static WAVE_HEADER RecorderWaveHeader = {
  3.     'R', 'I', 'F', 'F',
  5.     sizeof(WAVE_HEADER) - 8,//整个wave文件大小,初始化值
  7.     'W', 'A', 'V', 'E',
  9.     'f', 'm', 't', ' ',
  11.     sizeof(FMT_CHUNK) - 8,
  13.     1,//编码方式，线性PCM编码
  15.     1,//单声道
  17.     10000,//采样率为10k
  19.     20000,//每个采样2个字节
  21.     2,//每个采样2个字节
  23.     16,//每个采样需16位
  25.     'd', 'a', 't', 'a',
  27.     0, //data长度初始化为0
  29. };

2. wav音频文件的播放或录音

sd卡由于其可插拔、灵活性好，通常应用于设备的扩展存储应用。计算机上wav音频等文件可轻易地拷贝到fat32格式的sd卡上，在嵌入式系统中要使用sd卡，首先需实现sd卡驱动，这在前面的章节有详细的介绍，此处不再详述。fat32文件的读写还需要相应文件系统的接口支持，此处选用Fatfs，对于不同的嵌入式系统，这是需要移植的部分，关于s3c2416下Fatfs文件系统的移植在前面章节有详细的介绍，此处不再详述。从wav文件读出音频数据后(播放)，还需要把音频数据传输给声卡，声卡还原出声音模拟信号，即可听到声音。音频数据的处理需要用到音频编解码器，数据的传输也有一定的音频总线要求，因此还需要音频驱动的实现，这部分在前面的章节有详细的介绍，此处不再详述。

3. 应用实例

工程中利用串口对耳机音量进行加大、调小，对Mic录音进行灵敏度的调节，通过串口输入进行播放wav音频或开始录音。播放时实时显示播放进度并可按下’s’后停止播放，录音时实时显示录音wav文件的大小并可按下’s’后停止录音。

main.c的内容如下:

  1. #include"s3c2416.h"
  3. #include"UART0.h"
  5. #include"ff.h"
  7. #include"diskio.h"
  9. #include "RTC.h"
  11. #include"Wav.h"
  13. #include"IIS.h"
  15. #include"IIC.h"
  17. #include"WM8960.h"
  21. staticWAVE_HEADER RecorderWaveHeader = {
  23.     'R', 'I', 'F', 'F',
  25.     sizeof(WAVE_HEADER) - 8,//整个wave文件大小
  27.     'W', 'A', 'V', 'E',
  29.     'f', 'm', 't', ' ',
  31.     sizeof(FMT_CHUNK) - 8,
  33.     1,//编码方式，线性PCM编码
  35.     1,//单声道
  37.     10000,//采样率为10k
  39.     20000,//每个采样2个字节
  41.     2,//每个采样2个字节
  43.     16,//每个采样需16位
  45.     'd', 'a', 't', 'a',
  47.     0, //data长度初始化为0
  49. };
  53. // 音频数据缓存20KB
  55. unsigned charAudioBuffer[20*1024];
  59. int main()
  61. {
  63.     FATFS fs;
  65.     FIL file;
  67.     FRESULT Res;
  69.     unsigned int i;
  71.     unsigned int BufferLen;
  73.     unsigned char *pData;
  75.     WAVE_HEADER WaveHeader;
  77.     int ByteWrite, ByteRead;
  79.     unsigned char State;
  81.     unsigned char VolumeLevel;
  83.     unsigned short Command;
  85.     const char Path1[] = "test.wav";
  87.     const char Path2[] = "1.wav";
  89.     char FilePath[256];
  93.     unsigned int Size = 0;
  95.     unsigned int AudioSize = 0;
  97.     unsigned int TotalSize = 0;
  101.     RTC_Time Time = {
  103.         2014, 5, 22, 23, 00, 0, 5
  105.     }; 
  109.     RTC_Init(&Time); // RTC初始化
  111.     Uart0_Init(); // 串口初始化
  113.     IIC_Init(); //IIC初始化,音频芯片控制
  115.     IIS_Init(); // IIS音频接口初始化
  117.     WM8960_Init(); // 音频编解码器初始化
  119.     RTC_GetTime(&Time); // 显示RTC时间
  121.     Uart0_Printf("Time: %4d/%02d/%02d%02d:%02d:%02d\r\n", Time.Year,
  123.                 Time.Month, Time.Day, Time.Hour,Time.Min, Time.Sec);  
  125.     f_mount(&fs, "" , 0);          
  127.     ByteRead = 0;
  129.     pData = (unsigned char *)0;
  131.     for (i=0; i<sizeof(Path1); i++) {
  133.         FilePath[i] = Path1[i];
  135.     }
  137.     State = 1; // 进入播放test.wav状态
  139.     while(1) {
  141.     switch (State) {
  143.     case 0: // 操作选择
  145.         WM8960_HeadphoneStop();
  147.         WM8960_RecorderStop();
  149.         IIS_TxPause();
  151.         IIS_RxPause();
  153.         Uart0_SendString("\r\nSelect:\r\n"
  155.                          "0: Play test.wav\r\n"
  157.                          "1: Play recording file\r\n"
  159.                          "2: Start recorder\r\n"
  161.                          "3: Recorder volume up\r\n"
  163.                          "4: Recorder volume down\r\n"
  165.                          "5: Player volume up\r\n"
  167.                          "6: Player volume down\r\n"
  169.                         );
  171.         while(State == 0) {
  173.             // 等待串口选择操作,阻塞型
  175.             Command = Uart0_ReceiveByte();
  177.             switch (Command) {
  179.             case '0': // 播放test.wav
  181.                 for (i=0; i<sizeof(Path1);i++) {
  183.                     FilePath[i] = Path1[i];
  185.                 }
  187.                 State = 1; // 转到开始播放wav状态
  189.                 break;
  191.             case '1': // 播放录音wav
  193.                 for (i=0; i<sizeof(Path2);i++) {
  195.                     FilePath[i] = Path2[i];
  197.                 }
  199.                 State = 1; // 转到开始播放wav状态 
  201.                 break;
  203.             case '2':
  205.                 State = 3;  // 转到开始录音状态    
  207.                 break;
  209.             case '3': // Mic灵敏度增加
  211.                 VolumeLevel = WM8960_RecorderVolume(VolumeUp);
  213.                 Uart0_Printf("Recordervolume %d%%\r\n", VolumeLevel);
  215.                 break;
  217.             case '4': // Mic灵敏度减小
  219.                 VolumeLevel =WM8960_RecorderVolume(VolumeDown);
  221.                 Uart0_Printf("Recorder volume%d%%\r\n", VolumeLevel);
  223.                 break;
  225.             case '5': // 耳机音量增加
  227.                 VolumeLevel =WM8960_HeadphoneVolume(VolumeUp);
  229.                 Uart0_Printf("Player volume%d%%\r\n", VolumeLevel);                       
  231.                 break;
  233.             case '6': // 耳机音量降低
  235.                 VolumeLevel =WM8960_HeadphoneVolume(VolumeDown);
  237.                 Uart0_Printf("Player volume%d%%\r\n", VolumeLevel);
  239.                 break;             
  241.             default:
  243.                 break; 
  245.             }
  247.         }
  249.         Uart0_SendString("\r\n");
  251.         break;
  255.     case 1: // 开始播放音频
  257.         // 打开wav音频文件
  259.         Res = f_open(&file, FilePath, FA_READ | FA_OPEN_EXISTING);
  261.         if (Res != RES_OK) {
  263.             Uart0_Printf("Open %s failed\r\n",FilePath);
  265.             State = 0; // 进入到操作选择界面
  267.         } else {
  269.             // 读取wav音频文件头,获得音频采样率,位数,声道数信息
  271.             Res = f_read(&file, (unsignedchar *)&WaveHeader,
  273.                     sizeof(WAVE_HEADER),(unsigned int *)&ByteRead);
  275.             if (Res != RES_OK) {
  277.                 f_close(&file);
  279.                 Uart0_Printf("Read wavheader error\r\n");
  281.                 State = 0; // 进入到操作选择界面
  283.             } else {
  285.                 // 读取一小段音频数据到缓存中
  287.                 Res = f_read(&file,(unsigned int *)AudioBuffer,
  289.                     sizeof(AudioBuffer), (unsignedint *)&ByteRead);
  291.                 if (Res != RES_OK) {
  293.                     Uart0_Printf("Read wavdata error\r\n");   
  295.                     f_close(&file);
  297.                     State = 0; // 进入到操作选择界面
  299.                 } else {
  301.                     if (ByteRead <sizeof(AudioBuffer)) { // 文件到结尾
  303.                         // 已播放到文件的结尾,重定位到音频文件的开始
  305.                         Res = f_lseek(&file,sizeof(WAVE_HEADER));
  307.                         if (Res != RES_OK) {   
  309.                             Uart0_Printf("f_lseek error\r\n");
  311.                             f_close(&file);
  313.                             State= 0; // 进入到操作选择界面
  315.                             break;
  317.                         }
  319.                     }
  321.                     // 根据wav文件头的音频信息初始化音频驱动的播放参数
  323.                 IIS_TxInit(WaveHeader.FmtChunk.WaveFormat.SamplesPerSec,
  325.                     WaveHeader.FmtChunk.WaveFormat.BitsPerSample,
  327. WaveHeader.FmtChunk.WaveFormat.Channels);
  329.                     // wav文件的总文件大小,bytes计
  331.                     TotalSize =WaveHeader.RiffHeader.Riff_Size;
  333.                     pData = AudioBuffer; // 播放指向音频缓存区
  335.                     // 把pData指向的数据写入音频缓存,最大允许写入
  337.                     // ByteRead字节,返回实际写入到音频缓存的字节数
  339.                     BufferLen = IIS_WriteBuffer(pData,ByteRead);
  341.                     ByteRead -= BufferLen; // 数据剩余字节数
  343.                     pData += BufferLen; // 数据下一次开始写入的位置
  345.                     Size = BufferLen; // 播放的长度
  347.                     AudioSize = 0; // 已播放的音频长度
  349.                     WM8960_HeadphoneStart(); // 打开耳机播放通道
  351.                     IIS_TxStart(); // IIS开始传输音频播放
  353.                     State= 2; // 转入正在播放音频状态
  355.                     Uart0_SendString("PlayingMusic, press 's' to stop"
  357.                                 "playing at any time\r\n");
  359.                     Uart0_SendString("Playbackprogress: 00.0%");
  361.                 }
  363.             }
  365.         }  
  367.         break; 
  371.     case 2:// 正在播放音频
  373.         if (ByteRead > 0) {    
  375.         // 返回值的高8位不为0,说明低8位键值有效,查询是否有串口输入,非阻塞
  377.             Command = Uart0_Peek();
  379.             if (Command & (0xff<<8)) {// 有按键按下
  381.                 if ((Command & 0xff) == 's'){ // 按下了's'
  383.                     f_close(&file);
  385.                     State = 0; // 返回到操作选择界面
  387.                     break;
  389.                 }
  391.             }
  393.             if (Size > 20*1024) { // 播放了20k大小的音频数据
  395.                 AudioSize += (Size>>10);// 累计己播放的总音频数据大小(KB)
  397.                 Size = 0;
  399.                 Uart0_SendString("\b\b\b\b\b");
  401.                 // 显示播放进度的百分比
  403.                 Uart0_Printf("%02d.%d%%",(AudioSize*100)/(TotalSize>>10),
  405.  ((AudioSize*100)%(TotalSize>>10))*10/(TotalSize>>10));
  407.             }
  409.             // 连续写入音频数据到音频缓存中,实现连续播放
  411.             BufferLen = IIS_WriteBuffer(pData,ByteRead);
  413.             ByteRead -= BufferLen; // 数据剩余字节数
  415.             pData += BufferLen; // 数据下一次开始写入的位置
  417.             Size += BufferLen;
  419.         } else { // 播放完缓存中的音频数据,再从sd卡加载下一段音频数据
  421.             // 一段音频数据播放完后,从sd卡中加载下一段数据
  423.             Res = f_read(&file, (unsignedchar *)AudioBuffer,
  425.                     sizeof(AudioBuffer),(unsigned int *)&ByteRead);
  427.             if (Res != RES_OK) {
  429.                 Uart0_Printf("Read wav dataerror\r\n");   
  431.                 f_close(&file);
  433.                 State = 0; // 进入到操作选择界面
  435.             } else {       
  437.                 pData = AudioBuffer; // 重定位到数据首位置
  439.                 if (ByteRead <sizeof(AudioBuffer)) {
  441.                     // 到文件结尾,文件重定位到开头,重播放
  443.                     Uart0_Printf("\r\n");
  445.                     Uart0_Printf("replay%s\r\n", FilePath);
  447.                     Uart0_SendString("Playbackprogress: 00.0%");
  449.                     Size = 0;
  451.                     AudioSize = 0;
  453.                     Res = f_lseek(&file,sizeof(WAVE_HEADER));
  455.                     if (Res != RES_OK) {   
  457.                         Uart0_Printf("Replayaudio error\r\n");
  459.                         f_close(&file);
  461.                         State = 0; // 进入到操作选择界面
  463.                     }
  465.                 }
  467.             }
  469.         }
  471.         break;
  475.     case 3: // 开始录音
  477.         // 创建录音保存1.wav文件
  479.         Res = f_open(&file, "1.wav",FA_WRITE | FA_CREATE_ALWAYS);
  481.         if (Res != RES_OK) {       
  483.             Uart0_Printf("Create 1.wavfailed\r\n");
  485.             State = 0; // 进入到操作选择界面
  487.         } else {
  489.             // 写入wav文件头
  491.             Res = f_write(&file, (unsignedchar *)&RecorderWaveHeader,
  493.                     sizeof(WAVE_HEADER), (unsignedint *)&ByteWrite);
  495.             if (Res != RES_OK) {
  497.                 f_close(&file);
  499.                 Uart0_Printf("Write wavheader error\r\n");
  501.                 State = 0; // 进入到操作选择界面
  503.             } else {
  505.             // 初始化录音参数,采样率,采样位数,声道数
  507.             IIS_RxInit(RecorderWaveHeader.FmtChunk.WaveFormat.SamplesPerSec,
  509. RecorderWaveHeader.FmtChunk.WaveFormat.BitsPerSample,
  511. RecorderWaveHeader.FmtChunk.WaveFormat.Channels);
  513.                 Size = 0;
  515.                 AudioSize = 0; // 总录音文件大小初始化0
  517.                 pData = AudioBuffer; // 指向录音缓存区
  519.                 ByteWrite = sizeof(AudioBuffer);// 一段音频缓存的大小
  521.                 WM8960_RecorderStart(); //WM8960打开录音通道
  523.                 IIS_RxStart(); // IIS开始接收录音数据
  525.                 State = 4; // 转到正在录音状态     
  527.                 Uart0_SendString("Recording,press 's' to stop recording"
  529.                            "at any time\r\n");
  531.                 Uart0_SendString("Recording(KB):       ");
  533.             }
  535.         }
  537.         break;
  541.     case 4:// 正在录音
  543.         if (ByteWrite > 0) {
  545.         // 返回值的高8位不为0,说明低8位键值有效,查询是否有串口输入,非阻塞
  547.             Command = Uart0_Peek();
  549.             if (Command & (0xff<<8)) {// 有按键按下
  551.                 if ((Command & 0xff) == 's'){ // 按下了's'
  553.                     // 停止录音,更改wav文件头文件大小
  555.                     f_lseek(&file, 0); // 定位到文件头
  557.                     // 数据大小改为录音的音频大小
  559.                     RecorderWaveHeader.DataChunk.Data_Size= AudioSize;
  561.                     // RIFF大小改为整个文件文件的大小
  563.                     RecorderWaveHeader.RiffHeader.Riff_Size=
  565. (sizeof(WAVE_HEADER)-8) + AudioSize;
  567.                     // 更改wav文件头信息
  569.                     f_write(&file, (unsignedchar *)&RecorderWaveHeader,
  571.                     sizeof(WAVE_HEADER),(unsigned int *)&ByteWrite);
  573.                     f_close(&file);
  575.                     State = 0; // 进入到操作选择界面
  577.                     break;
  579.                 }
  581.             }          
  583.             if (Size > 20*1024) { // 记录了20k大小的音频数据
  585.                 AudioSize += Size; // 累计己播放的总音频数据大小
  587.                 Size = 0;
  589.                 Uart0_SendString("\b\b\b\b\b\b");
  591.                 // 显示已录音的文件大小
  593.                 Uart0_Printf("%6d",(AudioSize>>10));
  595.             }
  597.             // 从音频缓存中读取录音数据到pData中,最大允许读取ByteWrite
  599.             // 字节大小,返回实际从音频缓存中读取的字节数
  601.             BufferLen = IIS_ReadBuffer(pData,ByteWrite);
  603.             ByteWrite -= BufferLen; // 剩余内存空间字节数
  605.             pData += BufferLen; // 下一位读开始存入的内存位置  
  607.             Size += BufferLen;
  609.         } else { // 缓存已满,写入缓存数据到sd卡中
  611.             Res = f_write(&file, (unsignedchar *)&AudioBuffer,
  613.                     sizeof(AudioBuffer),(unsigned int *)&ByteWrite);
  615.             if (Res != RES_OK) {
  617.                 f_close(&file);
  619.                 Uart0_Printf("Write 1.waverror\r\n");
  621.                 State = 0; // 进入到操作选择界面
  623. } else {
  625.                 pData = AudioBuffer;
  627.                 ByteWrite = sizeof(AudioBuffer);
  629.             }
  631.         }
  633.         break;
  637.     default:
  639.         break;
  641.     }
  643. }
  645. }

19_Fatfs下播放录音wav音频文件 - 图1

4. 附录

通过Fatfs的api函数，可以轻易读写windows下常见格式文件，这和windows/Linux下操作文件差异不大。播放对wav音频文件无特殊要求，可任意采样率、采样位数、单/双声道，插上耳机即能听到声音，录制wav音频对采样率、采样位数、声道数、录制长度等均没有任何限制，录制好的wav音频文件可直接在计算机上播放。虽然wav格式音频文件较占用存储空间，但其是无损的，音质在相同码率下远好于mp3等有损压缩音频文件。

Wav_GCC.rar，GCC下wav音频文件播放与录制工程，可直接make。

http://pan.baidu.com/s/1c05s2cg

Wav_MDK.rar，MDK下wav音频文件播放与录制工程

http://pan.baidu.com/s/1i33guiD

test.wav，wav播放测试音频文件，11.025k采样率、16位、单声道音乐，可通过音频格式转换软件生成wav音频文件。

http://pan.baidu.com/s/1eQzOErg