WAVE文件格式剖析

　　WAVE文件作为多媒体中使用的声波文件格式之一，它是以 RIFF格式为标准的。RIFF是英文Resource Interchange File Format的缩写，每个WAVE文件的头四个字节便是“RIFF”。WAVE文件由文件头和数据体两大部分组成。其中文件头又分为RIFF／WAV文件 标识段和声音数据格式说明段两部分。WAVE文件各部分内容及格式见附表。
　　常见的声音文件主要有两种，分别对应于单声道（11.025KHz 采样率、8Bit的采样值）和双声道（44.1KHz采样率、16Bit的采样值）。采样率是指：声音信号在“模→数”转换过程中单位时间内采样的次数。 采样值是指每一次采样周期内声音模拟信号的积分值。
　　对于单声道声音文件，采样数据为八位的短整数（short int 00H-FFH）；而对于双声道立体声声音文件，每次采样数据为一个16位的整数（int），高八位和低八位分别代表左右两个声道。
W　　AVE文件数据块包含以脉冲编码调制（PCM）格式表示的样本。WAVE文件是由样本组织而成的。在单声道WAVE文件中，声道0代表左声道，声道1代表右声道。在多声道WAVE文件中，样本是交替出现的。
　　WAVE文件格式说明表　　
　　偏移地址  字节数   数据类型          内 容
　
　　文件头
　　00H      4           char        "RIFF"标志
　　04H      4         long int      文件长度
　　08H      4           char        "WAVE"标志
　　0CH      4           char        "fmt"标志
　　10H      4 　                    过渡字节（不定）
　　14H      2            int        格式类别（10H为PCM形式的声音数据)
　　16H      2            int        通道数，单声道为1，双声道为2
　　18H      2            int        采样率（每秒样本数），表示每个通道的播放速度，
　　1CH      4         long int      波形音频数据传送速率，其值为通道数×每秒数据位数×每样本的数据位数／8。播放软件利用此值可以估计缓冲区的大小。
　　20H      2         int      数据块的调整数（按字节算的），其值为通道数×每样本的数据位值／8。播放软件需要一次处理多个该值大小的字节数据，以便将其值用于缓冲区的调整。
　　22H      2 　                    每样本的数据位数，表示每个声道中各个样本的数据位数。如果有多个声道，对每个声道而言，样本大小都一样。
　　24H      4         char             数据标记符＂data＂
　　28H      4        long int          语音数据的长度
　　PCM数据的存放方式：
　　样本1 样本2
　　8位单声道 0声道 0声道
　　8位立体声 0声道（左） 1声道（右） 0声道（左） 1声道（右）
　　16位单声道 0声道低字节 0声道高字节 0声道低字节 0声道高字节
　　16位立体声 0声道（左）低字节 0声道（左）高字节 1声道（右）低字节 1声道（右）高字节
　　WAVE文件的每个样本值包含在一个整数i中，i的长度为容纳指定样本长度所需的最小字节数。首先存储低有效字节，表示样本幅度的位放在i的高有效位上，剩下的位置为0，这样8位和16位的PCM波形样本的数据格式如下所示。　
　　样本大小      数据格式               最大值     最小值
　　8位PCM         unsigned int          225         0
　　16位PCM       int                        32767    -32767

PCM脉码调制数字音频格式是70年代末发展起来的，记录媒体之一的CD，80年代初由飞利浦和索尼公司共同推出。PCM的音频格式也被DVD-A所采用，它支持立体声和5.1环绕声，1999年由DVD讨论会发布和推出的。

PCM 的比特率，从14-bit发展到16-bit、18-bit、20-bit直到24-bit；采样频率从44.1kHz发展到192kHz。到目前为止 PCM这项技术可以改善和提高的方面则越来越来小。只是简单的增加PCM比特率和采样率，不能根本的改善它的根本问题。其原因是PCM的主要问题在于： 1）任何PCM数字音频系统需要在其输入端设置急剧升降的滤波器，仅让20 Hz - 22.05 kHz的频率通过（高端22.05 kHz是由于CD 44.1 kHz的一半频率而确定），这是一项非常困难的任务。2）在录音时采用多级或者串联抽选的数字滤波器（减低采样率），在重放时采用多级的内插的数字滤波器 （提高采样率），为了控制小信号在编码时的失真，两者又都需要加入重复定量噪声。这样就限制了PCM技术在音频还原时的保真度。

为了全面改善PCM 数字音频技术，获得更好的声音质量，就需要有新的技术来替换。近年来飞利浦和索尼公司再次联手，共同推出一种称为直接流数字编码技术DSD的格式, 其记录媒体为超级音频CD即SACD，支持立体声和5.1环绕声

附：

wav文件格式分析详解

                                              
                                         

一、综述
    WAVE文件作为多媒体中使用的声波文件格式之一，它是以RIFF格式为标准的。
RIFF是英文Resource Interchange File Format的缩写，每个WAVE文件的头四个
字节便是“RIFF”。
    WAVE文件是由若干个Chunk组成的。按照在文件中的出现位置包括：RIFF WAVE
Chunk, Format Chunk, Fact Chunk(可选), Data Chunk。具体见下图：

------------------------------------------------
|             RIFF WAVE Chunk                  |
|             ID  = 'RIFF'                     |
|             RiffType = 'WAVE'                |
------------------------------------------------
|             Format Chunk                     |
|             ID = 'fmt '                      |
------------------------------------------------
|             Fact Chunk(optional)             |
|             ID = 'fact'                      |
------------------------------------------------
|             Data Chunk                       |
|             ID = 'data'                      |
------------------------------------------------
            图1   Wav格式包含Chunk示例

    其中除了Fact Chunk外，其他三个Chunk是必须的。每个Chunk有各自的ID，位
于Chunk最开始位置，作为标示，而且均为4个字节。并且紧跟在ID后面的是Chunk大
小（去除ID和Size所占的字节数后剩下的其他字节数目），4个字节表示，低字节
表示数值低位，高字节表示数值高位。下面具体介绍各个Chunk内容。
PS：
    所有数值表示均为低字节表示低位，高字节表示高位。

二、具体介绍
RIFF WAVE Chunk
    ==================================
    |       |所占字节数|  具体内容   |
    ==================================
    | ID    |  4 Bytes |   'RIFF'    |
    ----------------------------------
    | Size  |  4 Bytes |             |
    ----------------------------------
    | Type  |  4 Bytes |   'WAVE'    |
    ----------------------------------
            图2  RIFF WAVE Chunk

    以'FIFF'作为标示，然后紧跟着为size字段，该size是整个wav文件大小减去ID
和Size所占用的字节数，即FileLen - 8 = Size。然后是Type字段，为'WAVE'，表
示是wav文件。
    结构定义如下：
 struct RIFF_HEADER
 {
  char szRiffID[4];  // 'R','I','F','F'
  DWORD dwRiffSize;
  char szRiffFormat[4]; // 'W','A','V','E'
 };

Format Chunk
    ====================================================================
    |               |   字节数  |              具体内容                |
    ====================================================================
    | ID            |  4 Bytes  |   'fmt '                             |
    --------------------------------------------------------------------
    | Size          |  4 Bytes  | 数值为16或18，18则最后又附加信息     |
    --------------------------------------------------------------------  ----
    | FormatTag     |  2 Bytes  | 编码方式，一般为0x0001               |     |
    --------------------------------------------------------------------     |
    | Channels      |  2 Bytes  | 声道数目，1--单声道；2--双声道       |     |
    --------------------------------------------------------------------     |
    | SamplesPerSec |  4 Bytes  | 采样频率                             |     |
    --------------------------------------------------------------------     |
    | AvgBytesPerSec|  4 Bytes  | 每秒所需字节数                       |     |===> WAVE_FORMAT
    --------------------------------------------------------------------     |
    | BlockAlign    |  2 Bytes  | 数据块对齐单位(每个采样需要的字节数) |     |
    --------------------------------------------------------------------     |
    | BitsPerSample |  2 Bytes  | 每个采样需要的bit数                  |     |
    --------------------------------------------------------------------     |
    |               |  2 Bytes  | 附加信息（可选，通过Size来判断有无） |     |
    --------------------------------------------------------------------  ----
                            图3  Format Chunk

    以'fmt '作为标示。一般情况下Size为16，此时最后附加信息没有；如果为18
则最后多了2个字节的附加信息。主要由一些软件制成的wav格式中含有该2个字节的
附加信息。
    结构定义如下：
 struct WAVE_FORMAT
 {
  WORD wFormatTag;
  WORD wChannels;
  DWORD dwSamplesPerSec;
  DWORD dwAvgBytesPerSec;
  WORD wBlockAlign;
  WORD wBitsPerSample;
 };
 struct FMT_BLOCK
 {
  char  szFmtID[4]; // 'f','m','t',' '
  DWORD  dwFmtSize;
  WAVE_FORMAT wavFormat;
 };

Fact Chunk
    ==================================
    |       |所占字节数|  具体内容   |
    ==================================
    | ID    |  4 Bytes |   'fact'    |
    ----------------------------------
    | Size  |  4 Bytes |   数值为4   |
    ----------------------------------
    | data  |  4 Bytes |             |
    ----------------------------------
            图4  Fact Chunk

    Fact Chunk是可选字段，一般当wav文件由某些软件转化而成，则包含该Chunk。
    结构定义如下：
 struct FACT_BLOCK
 {
  char  szFactID[4]; // 'f','a','c','t'
  DWORD  dwFactSize;
 };

Data Chunk
    ==================================
    |       |所占字节数|  具体内容   |
    ==================================
    | ID    |  4 Bytes |   'data'    |
    ----------------------------------
    | Size  |  4 Bytes |             |
    ----------------------------------
    | data  |          |             |
    ----------------------------------
             图5 Data Chunk

    Data Chunk是真正保存wav数据的地方，以'data'作为该Chunk的标示。然后是
数据的大小。紧接着就是wav数据。根据Format Chunk中的声道数以及采样bit数，
wav数据的bit位置可以分成以下几种形式：
    ---------------------------------------------------------------------
    |   单声道  |    取样1    |    取样2    |    取样3    |    取样4    |
    |           |--------------------------------------------------------
    |  8bit量化 |    声道0    |    声道0    |    声道0    |    声道0    |
    ---------------------------------------------------------------------
    |   双声道  |          取样1            |           取样2           |
    |           |--------------------------------------------------------
    |  8bit量化 |  声道0(左)  |  声道1(右)  |  声道0(左)  |  声道1(右)  |
    ---------------------------------------------------------------------
    |           |          取样1            |           取样2           |
    |   单声道  |--------------------------------------------------------
    | 16bit量化 |    声道0    |  声道0      |    声道0    |  声道0      |
    |           | (低位字节)  | (高位字节)  | (低位字节)  | (高位字节)  |
    ---------------------------------------------------------------------
    |           |                         取样1                         |
    |   双声道  |--------------------------------------------------------
    | 16bit量化 |  声道0(左)  |  声道0(左)  |  声道1(右)  |  声道1(右)  |
    |           | (低位字节)  | (高位字节)  | (低位字节)  | (高位字节)  |
    ---------------------------------------------------------------------
                         图6 wav数据bit位置安排方式

    Data Chunk头结构定义如下：
    struct DATA_BLOCK
 {
  char szDataID[4]; // 'd','a','t','a'
  DWORD dwDataSize;
 };

三、小结
    因此，根据上述结构定义以及格式介绍，很容易编写相应的wav格式解析代码。
这里具体的代码就不给出了。

测试Wave-header的source：

#define _GNU_SOURCE
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <alsa/asoundlib.h>
#include <asm/byteorder.h>


#ifndef LLONG_MAX
#define LLONG_MAX 9223372036854775807LL
#endif

#define DEFAULT_FORMAT        SND_PCM_FORMAT_U8
#define DEFAULT_SPEED         8000

#define FORMAT_WAVE        2

/* Definitions for Microsoft WAVE format */

#if __BYTE_ORDER == __LITTLE_ENDIAN
#define COMPOSE_ID(a,b,c,d)    ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24))
#define LE_SHORT(v)        (v)
#define LE_INT(v)        (v)
#define BE_SHORT(v)        bswap_16(v)
#define BE_INT(v)        bswap_32(v)
#elif __BYTE_ORDER == __BIG_ENDIAN
#define COMPOSE_ID(a,b,c,d)    ((d) | ((c)<<8) | ((b)<<16) | ((a)<<24))
#define LE_SHORT(v)        bswap_16(v)
#define LE_INT(v)        bswap_32(v)
#define BE_SHORT(v)        (v)
#define BE_INT(v)        (v)
#else
#error "Wrong endian"
#endif

#define WAV_RIFF        COMPOSE_ID('R','I','F','F')
#define WAV_WAVE        COMPOSE_ID('W','A','V','E')
#define WAV_FMT            COMPOSE_ID('f','m','t',' ')
#define WAV_DATA        COMPOSE_ID('d','a','t','a')

/* WAVE fmt block constants from Microsoft mmreg.h header */
#define WAV_FMT_PCM 0x0001
#define WAV_FMT_IEEE_FLOAT 0x0003
#define WAV_FMT_DOLBY_AC3_SPDIF 0x0092
#define WAV_FMT_EXTENSIBLE 0xfffe

/* Used with WAV_FMT_EXTENSIBLE format */
#define WAV_GUID_TAG        "\x00\x00\x00\x00\x10\x00\x80\x00\x00\xAA\x00\x38\x9B\x71"

#define error(...) do {\
    fprintf(stderr, "%s: %s:%d: ", command, __FUNCTION__, __LINE__); \
    fprintf(stderr,__VA_ARGS__); \
    putc('\n', stderr); \
} while (0)


/* global data */

static char *command;
static snd_pcm_t *handle;
static struct {
    snd_pcm_format_t format;
    unsigned int channels;
    unsigned int rate;
} hwparams, rhwparams;

typedef struct {
    u_int magic;        /* 'RIFF' */
    u_int length;        /* filelen */
    u_int type;        /* 'WAVE' */
} WaveHeader;

typedef struct {
    u_short format;        /* see WAV_FMT_* */
    u_short channels;
    u_int sample_fq;    /* frequence of sample */
    u_int byte_p_sec;
    u_short byte_p_spl;    /* samplesize; 1 or 2 bytes */
    u_short bit_p_spl;    /* 8, 12 or 16 bit */
} WaveFmtBody;

typedef struct {
    WaveFmtBody format;
    u_short ext_size;
    u_short bit_p_spl;
    u_int channel_mask;
    u_short guid_format;    /* WAV_FMT_* */
    u_char guid_tag[14];    /* WAV_GUID_TAG */
} WaveFmtExtensibleBody;

typedef struct {
    u_int type;        /* 'data' */
    u_int length;        /* samplecount */
} WaveChunkHeader;

static u_char *audiobuf = NULL;

static int fd = -1;
static off64_t pbrec_count = LLONG_MAX, fdcount;



/*
 * Safe read (for pipes)
 */
 
static ssize_t safe_read(int fd, void *buf, size_t count)
{
    ssize_t result = 0, res;

    while (count > 0) {
        if ((res = read(fd, buf, count)) == 0)
            break;
        if (res < 0)
            return result > 0 ? result : res;
        count -= res;
        result += res;
        buf = (char *)buf + res;
    }
    return result;
}

/*
 * helper for test_wavefile
 */

static size_t test_wavefile_read(int fd, u_char *buffer, size_t *size, size_t reqsize, int line)
{
    if (*size >= reqsize)
        return *size;//这个时候，audiobuf中已经存在了下面要测试的内容，不需要重复读取

    if ((size_t)safe_read(fd, buffer + *size, reqsize - *size) != reqsize - *size) {
        error(("read error (called from line %i)"), line);
        exit(EXIT_FAILURE);
    }
    return *size = reqsize;
}

// 测试当前buffer容量够不够，blimit是buffer的长度，不够的话，重新申请内存

#define check_wavefile_space(buffer, len, blimit) \
    if (len > blimit) { \
        blimit = len; \
        if ((buffer = realloc(buffer, blimit)) == NULL) { \
            error("not enough memory");         \
            exit(EXIT_FAILURE); \
        } \
    }




/*
 * test, if it's a .WAV file, > 0 if ok (and set the speed, stereo etc.)
 * == 0 if not
 * Value returned is bytes to be discarded.
 */
static ssize_t test_wavefile(int fd, u_char *_buffer, size_t size)
{
    WaveHeader *h = (WaveHeader *)_buffer;
    u_char *buffer = NULL;
    size_t blimit = 0;
    WaveFmtBody *f;
    WaveChunkHeader *c;
    u_int type, len;

       // RIFF chunk测试

    if (size < sizeof(WaveHeader))
        return -1;
    if (h->magic != WAV_RIFF || h->type != WAV_WAVE)
        return -1;
        //buffer指针指向刚开始 读取的大块内存存放FMT开始的位置

    if (size > sizeof(WaveHeader)) {
        check_wavefile_space(buffer, size - sizeof(WaveHeader), blimit);
        memcpy(buffer, _buffer + sizeof(WaveHeader), size - sizeof(WaveHeader));
    }
    size -= sizeof(WaveHeader);
    
    // FMT chunk测试

    while (1) {
        check_wavefile_space(buffer, sizeof(WaveChunkHeader), blimit);
        test_wavefile_read(fd, buffer, &size, sizeof(WaveChunkHeader), __LINE__);
        c = (WaveChunkHeader*)buffer;
        type = c->type;
        len = LE_INT(c->length);
        len += len % 2;
        printf("FMT test : len = %d and size = %d \n",len,size);
        if (size > sizeof(WaveChunkHeader))
            memmove(buffer, buffer + sizeof(WaveChunkHeader), size - sizeof(WaveChunkHeader));
        size -= sizeof(WaveChunkHeader);
        if (type == WAV_FMT){
            printf("type is WAV_FMT and size = %d \n",size);
            break;
        }
                
        check_wavefile_space(buffer, len, blimit);
        test_wavefile_read(fd, buffer, &size, len, __LINE__);
        if (size > len)
            memmove(buffer, buffer + len, size - len);
        size -= len;
    }

    if (len < sizeof(WaveFmtBody)) {
        error(("unknown length of 'fmt ' chunk (read %u, should be %u at least)"),
         len, (u_int)sizeof(WaveFmtBody));
        exit(EXIT_FAILURE);
    }
    check_wavefile_space(buffer, len, blimit);
    test_wavefile_read(fd, buffer, &size, len, __LINE__);
    f = (WaveFmtBody*) buffer;
    if (LE_SHORT(f->format) == WAV_FMT_EXTENSIBLE) {
        WaveFmtExtensibleBody *fe = (WaveFmtExtensibleBody*)buffer;
        if (len < sizeof(WaveFmtExtensibleBody)) {
            error(("unknown length of extensible 'fmt ' chunk (read %u, should be %u at least)"),
                    len, (u_int)sizeof(WaveFmtExtensibleBody));
            exit(EXIT_FAILURE);
        }
        if (memcmp(fe->guid_tag, WAV_GUID_TAG, 14) != 0) {
            error(("wrong format tag in extensible 'fmt ' chunk"));
            exit(EXIT_FAILURE);
        }
        f->format = fe->guid_format;
    }
        if (LE_SHORT(f->format) != WAV_FMT_PCM &&
            LE_SHORT(f->format) != WAV_FMT_IEEE_FLOAT) {
                error(("can't play WAVE-file format 0x%04x which is not PCM or FLOAT encoded"), LE_SHORT(f->format));
        exit(EXIT_FAILURE);
    }
    if (LE_SHORT(f->channels) < 1) {
        error(("can't play WAVE-files with %d tracks"), LE_SHORT(f->channels));
        exit(EXIT_FAILURE);
    }
    hwparams.channels = LE_SHORT(f->channels);
    switch (LE_SHORT(f->bit_p_spl)) {
    case 8:
        if (hwparams.format != DEFAULT_FORMAT &&
         hwparams.format != SND_PCM_FORMAT_U8)
            fprintf(stderr,("Warning: format is changed to U8\n"));
        hwparams.format = SND_PCM_FORMAT_U8;
        break;
    case 16:
        if (hwparams.format != DEFAULT_FORMAT &&
         hwparams.format != SND_PCM_FORMAT_S16_LE)
            fprintf(stderr,("Warning: format is changed to S16_LE\n"));
        hwparams.format = SND_PCM_FORMAT_S16_LE;
        break;
    case 24:
        switch (LE_SHORT(f->byte_p_spl) / hwparams.channels) {
        case 3:
            if (hwparams.format != DEFAULT_FORMAT &&
             hwparams.format != SND_PCM_FORMAT_S24_3LE)
                fprintf(stderr,("Warning: format is changed to S24_3LE\n"));
            hwparams.format = SND_PCM_FORMAT_S24_3LE;
            break;
        case 4:
            if (hwparams.format != DEFAULT_FORMAT &&
             hwparams.format != SND_PCM_FORMAT_S24_LE)
                fprintf(stderr,("Warning: format is changed to S24_LE\n"));
            hwparams.format = SND_PCM_FORMAT_S24_LE;
            break;
        default:
            error((" can't play WAVE-files with sample %d bits in %d bytes wide (%d channels)"),
             LE_SHORT(f->bit_p_spl), LE_SHORT(f->byte_p_spl), hwparams.channels);
            exit(EXIT_FAILURE);
        }
        break;
    case 32:
                if (LE_SHORT(f->format) == WAV_FMT_PCM)
                        hwparams.format = SND_PCM_FORMAT_S32_LE;
                else if (LE_SHORT(f->format) == WAV_FMT_IEEE_FLOAT)
                        hwparams.format = SND_PCM_FORMAT_FLOAT_LE;
        break;
    default:
        error((" can't play WAVE-files with sample %d bits wide"),
         LE_SHORT(f->bit_p_spl));
        exit(EXIT_FAILURE);
    }
    hwparams.rate = LE_INT(f->sample_fq);
    
    if (size > len)
        memmove(buffer, buffer + len, size - len);
    size -= len;
    
    
    while (1) {
        u_int type, len;

        check_wavefile_space(buffer, sizeof(WaveChunkHeader), blimit);
        test_wavefile_read(fd, buffer, &size, sizeof(WaveChunkHeader), __LINE__);
        c = (WaveChunkHeader*)buffer;
        type = c->type;
        len = LE_INT(c->length);
        if (size > sizeof(WaveChunkHeader)) //处理刚开始读取了大块内存的情况

            memmove(buffer, buffer + sizeof(WaveChunkHeader), size - sizeof(WaveChunkHeader));
        size -= sizeof(WaveChunkHeader);
        if (type == WAV_DATA) {
            if (len < pbrec_count && len < 0x7ffffffe)
                pbrec_count = len;
            if (size > 0)
                memcpy(_buffer, buffer, size);
            free(buffer);
            return size;
        }
        len += len % 2;
        check_wavefile_space(buffer, len, blimit);
        test_wavefile_read(fd, buffer, &size, len, __LINE__);
        if (size > len)
            memmove(buffer, buffer + len, size - len);
        size -= len;
    }

    /* shouldn't be reached */
    return -1;
}

int main(int argc, char ** argv)
{
    int ofs;
    size_t dta;
    char * name;
    ssize_t dtawave;
    
    name = argv[1];

    pbrec_count = LLONG_MAX;
    fdcount = 0;
    if (!name || !strcmp(name, "-")) {
        fd = fileno(stdin);
        name = "stdin";
    } else {
        if ((fd = open64(name, O_RDONLY, 0)) == -1) {
            perror(name);
            exit(EXIT_FAILURE);
        }
    }
    
    audiobuf = (u_char *)malloc(1024);
    if (audiobuf == NULL) {
        error(("not enough memory"));
        return 1;
    }

    /* read the file header */
    dta = sizeof(WaveHeader);
    if ((size_t)safe_read(fd, audiobuf, dta) != dta) {
        error(("read error"));
        exit(EXIT_FAILURE);
    }
    /* read bytes for WAVE-header */
    if ((dtawave = test_wavefile(fd, audiobuf, dta)) >= 0) {
        printf("wave file header read ok! \n");
    } else{
        printf("wave file header read faulse! \n");
    }
        printf("return dtawave is %d \n",dtawave);
    if (audiobuf)
          free(audiobuf);
}