RIFF file format

RIFF全称为资源互换文件格式（Resources Interchange File Format），是Windows下大部分多媒体文件遵循的一种文件结构。RIFF文件所包含的数据类型由该文件的扩展名来标识

Chunk

RIFF文件结构可以看作是树状结构，其基本构成是称为"块"（Chunk）的单元，每个块有"标志符"、"数据大小"及"数据"所组成

 public static class Chunk {
        //4个字节
        public String chunkId;
        //4个字节。指的是 data的长度
        public int dataSize;
        public byte[] data;
    }

• chunkId
  4字节，用以标识块中所包含的数据。如：RIFF,LIST,fmt,data,WAV,AVI等。RIFF文件是按照小端little-endian字节顺序写入的。
• dataSize
  存储在data域中的数据长度
• data
  包含数据，数据以字为单位存放，如果数据长度为奇数（字节为单位），则最后添加一个空字节。

chunk是可以嵌套的，但是只有块标志为RIFF或者LIST的chunk才能包含其他的chunk。

RIFF chunk

标志为RIFF的chunk是比较特殊的，每一个RIFF文件首先存放的必须是一个RIFF chunk，并且只能有这一个标志为RIFF的chunk。RIFF的数据域的起始位置是一个4字节码（FOURCC），用于标识其数据域中chunk的数据类型；紧接着数据域的内容则是包含的subchunk，如下图

RIFF chunk

这是一个RIFF chunk中包含有两个subchunk，可以看出RIFF chunk的数据域首先是是4字节的 Form Type，接着是两个subchunk，每一个subchun有包含有自己的标识、数据域的大小以及数据域。

除了RIFF cunk可以嵌套其他的chunk外，另一个可以有subchunk的就是LIST chunk。

image

上图中，首先是RIFF文件必须的RIFF chunk，其数据域又包含有两个subchunk，其中一个subchunk的类型为LIST，该LIST chunk又包含了两个subchunk。

FourCC

FourCC 全称为Four-Character Codes，是一个4字节32位的标识符，通常用来标识文件的数据格式。例如，在音视频播放器中，可以通过 文件的FourCC来决定调用那种CODEC进行视音频的解码。例如：DIV3,DIV4,DIVX,H264等，对于音频则有：WAV,MP3等。对于上面的RIFF文件，则有：RIFF,WAVE,fmt,data等。FourCC是4个ASCII字符，不足四个字符的则在最后补充空格（不是空字符）。比如，FourCC fmt，实际上是'f' 'm' 't' ' '。

WAV

WAV 是Microsoft开发的一种音频文件格式，它符合上面提到的RIFF文件格式标准，可以看作是RIFF文件的一个具体实例。既然WAV符合RIFF规范，其基本的组成单元也是chunk。一个WAV文件通常有三个chunk以及一个可选chunk，其在文件中的排列方式依次是：RIFF chunk，Format chunk，Fact chunk（附加块，可选），Data chunk。

image.png

一个WAV文件，首先是一个RIFF chunk；RIFF chunk又包含有Format chunk，Data chunk以及可选的Fact chunk。各个chunk中字段的意义如下：

RIFF chunk

Format chunk

chunk size

数据字段包含数据的大小。如无扩展块，则值为16；有扩展块，则值为= 16 + 2字节扩展块长度 + 扩展块长度或者值为18（只有扩展块的长度为2字节，值为0）

chunk Data

存放音频格式、声道数、采样率等信息

• format_tag
  2字节，表示音频数据的格式。如值为1，表示使用PCM格式。
• channels
  2字节，声道数。值为1则为单声道，为2则是双声道。
• samples_per_sec
  采样率，主要有22.05KHz，44.1kHz和48KHz。
• bytes_per sec
  音频的码率，每秒播放的字节数。samples_per_sec * channels * bits_per_sample / 8，可以估算出使用缓冲区的大小
• block_align
  数据块对齐单位，一次采样的大小，值为声道数 * 量化位数 / 8，在播放时需要一次处理多个该值大小的字节数据。
• bits_per_sample
  音频sample的量化位数，有16位，24位和32位等。
• cbSize
  扩展区的长度

扩展块内容

22字节，具体介绍，后面补充。

• Fact chunk**(option)

采用压缩编码的WAV文件，必须要有Fact chunk，该块中只有一个数据，为每个声道的采样总数。

Data chunk

补充

Format chunk 中的编码方式

在Format chunk中，除了有音频的数据的采样率、声道等音频的属性外，另一个比较主要的字段就是format_tag，该字段表示音频数据是以何种方式编码存放的。其具体的取值可以为以下：

关于扩展格式块

当WAV文件使用的不是PCM编码方式是，就需要扩展格式块，它是在基本的Format chunk又添加一段数据。该数据的前两个字节，表示的扩展块的长度。紧接其后的是扩展的数据区，含有扩展的格式信息，其具体的长度取决于压缩编码的类型。当某种编码方式（如 ITU G.711 a-law）使扩展区的长度为0，扩展区的长度字段还必须保留，只是其值设置为0。

扩展区的各个字节的含义如下：

• size 2字节
  扩展区的数据长度 ，可以为0或22
• valid_bits_per_sample 2字节
  有效的采样位数，最大值为采样字节数 * 8。可以使用更灵活的量化位数，通常音频sample的量化位数为8的倍数，但是使用了WAVE_FORMAT_EXTENSIBLE时，量化的位数有扩展区中的valid bits per sample来描述，可以小于Format chunk中制定的bits per sample。
• channle mask 4字节
  声道掩码
• sub format 16字节
  GUID，include the data format code，数据格式码。

在Format chunk中的format_tag设置为0xFFFE时，表示使用扩展区中的sub_format来决定音频的数据的编码方式。在以下几种情况下必须要使用WAVE_FORMAT_EXTENSIBLE

• PCM数据的量化位数大于16
• 音频的采样声道大于2
• 实际的量化位数不是8的倍数
• 存储顺序和播放顺序不一致，需要指定从声道顺序到声卡播放顺序的映射情况。

Data chunk

Data块中存放的是音频的采样数据。每个sample按照采样的时间顺序写入，对于使用多个字节的sample，使用小端模式存放（低位字节存放在低地址，高位字节存放在高地址）。对于多声道的sample采用交叉存放的方式。例如：立体双声道的sample存储顺序为：声道1的第一个sample，声道2的第一个sample；声道1的第二个sample，声道2的第二个sample；依次类推....。对于PCM数据，有以下两种的存储方式：

• 单声道，量化位数为8，使用偏移二进制码
• 除上面之外的，使用补码方式存储。

实例分析

普通的WAV

image.png

RIFF块

由上面的介绍可知，由RIFF格式固定的。包括RIFF、Size和FOURCC

• RIFF

  
  RIFF.png

• Size

  
  Size.png

  因为是小端的顺序。实际上的十六进制数应该是 “00077090”，转为487568。这个数值+8，就是文件的长度。

• WAVE

  
  WAVE.png

Format chunk

• ChunkId

  "fmt "。和上面标识的一样。是4个字节，不足补“ ”

  
  image.png

• Chunk Size

  
  image.png

  因为是小端的顺序。实际上的十六进制数应该是 “00000010”，为16。就是后续的Data的长度。

• Chunk Data

  fmt chunk中的chunk data就是包含有该视频的信息。

  
  Chunk Data.png

Data

因为是PCM的数据格式，所以直接就到了data

• 标识'data'

  
  data.png
• 音频数据的长度Size
  
  Size.png

总结

• 头部大小
  通常的WAV，以PCM为数据格式的，基本上头部就如上面的结构。头部的SIZE为固定的44,
  通常对WAV音频进行处理时，会直接写死这个头部的Offset。

排查一次WAV处理中的杂音情况

但是在实际处理的过程中，遇到了下面这样的WAV HEADER。头部的长度不同，导致后续的音频处理中出现了杂音的情况。排查之后，才发现是因为头部大小不同导致。

特殊一点的WAV

由Adobe Premiere Pro CC 创建的WAV。

image.png

它包含有LIST Chunk。而且fmt chunk的size为18。

wav list.png

因为有LIST,导致上面通常写死的HEAD_SIZE 44出现错误。

这个时候重新去计算这个HEAD_SIZE就可以了。

LIST CHUNK

• CHUNK ID
  CHUNK ID为“LIST”
• CHUNK SIZE
  可以看到为0x58，十进制为88。

计算HEAD_SIZE

    private static int getHeadSize(RandomAccessFile srcFis) throws IOException {
        int offset = 0;
        //riff
        getChunkId(srcFis);
        offset += 4;
        //length
        getChunkSize(srcFis);
        offset += 4;
        //wave
        getChunkId(srcFis);
        offset += 4;
        //fmt
        getChunkId(srcFis);
        offset += 4;
        //fmt length
        int skipLength = getChunkSize(srcFis);
        offset += 4;
        byte[] skipBytes = new byte[skipLength];
        srcFis.read(skipBytes);
        offset += skipLength;
        String chunkId = getChunkId(srcFis);
        offset += 4;
        while (!chunkId.equals("data")) {
            skipLength = getChunkSize(srcFis);
            offset += 4;
            skipBytes = new byte[skipLength];
            srcFis.read(skipBytes);
            offset += skipLength;
            chunkId = getChunkId(srcFis);
            offset += 4;
        }
        offset += 4;
        System.out.println("headSize="+offset);
        return offset;
    }

    private static int getChunkSize(RandomAccessFile srcFis) throws IOException {
        byte[] formatSize = new byte[4];
        srcFis.read(formatSize);
        int fisrt8 = formatSize[0] & 0xFF;  
        int fisrt16 = formatSize[1] & 0xFF;
        int fisrt24 = formatSize[2] & 0xFF;
        int fisrt32 = formatSize[3] & 0xFF;
        int chunkSize = fisrt8 | (fisrt16 << 8) | (fisrt24 << 16) | (fisrt32 << 24);
        System.out.println("ChunkSize=" + chunkSize);
        return chunkSize;
    }

    private static String getChunkId(RandomAccessFile srcFis) throws IOException {
        byte[] bytes = new byte[4];
        srcFis.read(bytes);
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            stringBuilder.append((char) bytes[i]);
        }
        String chunkId = stringBuilder.toString();
        System.out.println("ChunkId=" + chunkId);
        return chunkId;
    }

只有这样计算出的HEAD_SIZE才能正确的处理文件，避免因为这个原因导致的杂音。

WAV一些处理

获取wave文件某个时间对应的数据位置

    private static int getPositionFromWave(float time, int sampleRate, int channels, int bitNum) {
        int byteNum = bitNum / 8;
        //时间* 每秒数据字节数= 当前时间的字节数
        int position = (int) (time * sampleRate * channels * byteNum);
        //当前时间的字节数 / 每个采样所需的字节数 * 当前时间的字节数 来进行取整。定位到一个完整的采样的起点
        position = position / (byteNum * channels) * (byteNum * channels);

        return position;
    }

• 当前时间的字节数
  sampleRate * channels * byteNum
• 定位到完整的采样时间的起点
  position = position / (byteNum * channels) * (byteNum * channels);

剪切音频

剪切音频的流程很简单

1. 计算两个采样点的位置。偏移头部的大小，复制两个采样点之间的数据。
2. 重新写入修改之后的头部。因为数据长度修改。里面的RIFF块ChunkSize和data块的长度由当前的长度做对应修改。

 public static void cutAudio(Audio audio, Audio audioOut, float cutStartTime, float cutEndTime) {
        if (cutStartTime == 0 && cutEndTime == audio.getTimeMillis() / 1000f) {
            return;
        }
        if (cutStartTime >= cutEndTime) {
            return;
        }

        String srcWavePath = audio.getPath();
        int sampleRate = audio.getSampleRate();
        int channels = audio.getChannel();
        int bitNum = audio.getBitNum();
        RandomAccessFile srcFis = null;
        RandomAccessFile newFos = null;
        String tempOutPath = srcWavePath + ".temp";
        try {

            //创建输入流
            srcFis = new RandomAccessFile(srcWavePath, "rw");
            newFos = new RandomAccessFile(tempOutPath, "rw");

            //源文件开始读取位置，结束读取文件，读取数据的大小
            final int cutStartPos = getPositionFromWave(cutStartTime, sampleRate, channels, bitNum);
            final int cutEndPos = getPositionFromWave(cutEndTime, sampleRate, channels, bitNum);
            final int contentSize = cutEndPos - cutStartPos;

            //复制wav head 字节数据
            byte[] headerData = AudioEncodeUtil.getWaveHeader(contentSize, sampleRate, channels, bitNum);
            copyHeadData(headerData, newFos);

            //取到正确头部偏移
            int srcHeadSize = getHeadSize(srcFis);
            //移动到文件开始读取处
            srcFis.seek(srcHeadSize + cutStartPos);

            //复制裁剪的音频数据
            copyData(srcFis, newFos, contentSize);

        } catch (Exception e) {
            e.printStackTrace();

            return;

        } finally {
            //关闭输入流
            if (srcFis != null) {
                try {
                    srcFis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (newFos != null) {
                try {
                    newFos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //重命名为源文件
        FileUtil.renameFile(new File(tempOutPath), audioOut.getPath());

    }

    public static byte[] getWaveHeader(long totalAudioLen, int sampleRate, int channels, int bitNum) throws IOException {

        //总大小，由于不包括RIFF和WAV，所以是44 - 8 = 36，在加上PCM文件大小
        long totalDataLen = totalAudioLen + 36;
        //采样字节byte率
        long byteRate = sampleRate * channels * bitNum / 8;

        byte[] header = new byte[44];
        header[0] = 'R'; // RIFF
        header[1] = 'I';
        header[2] = 'F';
        header[3] = 'F';
        header[4] = (byte) (totalDataLen & 0xff);//数据大小
        header[5] = (byte) ((totalDataLen >> 8) & 0xff);
        header[6] = (byte) ((totalDataLen >> 16) & 0xff);
        header[7] = (byte) ((totalDataLen >> 24) & 0xff);
        header[8] = 'W';//WAVE
        header[9] = 'A';
        header[10] = 'V';
        header[11] = 'E';
        //FMT Chunk
        header[12] = 'f'; // 'fmt '
        header[13] = 'm';
        header[14] = 't';
        header[15] = ' ';//过渡字节
        //数据大小
        header[16] = 16; // 4 bytes: size of 'fmt ' chunk
        header[17] = 0;
        header[18] = 0;
        header[19] = 0;
        //编码方式 10H为PCM编码格式
        header[20] = 1; // format = 1
        header[21] = 0;
        //通道数
        header[22] = (byte) channels;
        header[23] = 0;
        //采样率，每个通道的播放速度
        header[24] = (byte) (sampleRate & 0xff);
        header[25] = (byte) ((sampleRate >> 8) & 0xff);
        header[26] = (byte) ((sampleRate >> 16) & 0xff);
        header[27] = (byte) ((sampleRate >> 24) & 0xff);
        //音频数据传送速率,采样率*通道数*采样深度/8
        header[28] = (byte) (byteRate & 0xff);
        header[29] = (byte) ((byteRate >> 8) & 0xff);
        header[30] = (byte) ((byteRate >> 16) & 0xff);
        header[31] = (byte) ((byteRate >> 24) & 0xff);
        // 确定系统一次要处理多少个这样字节的数据，确定缓冲区，通道数*采样位数
        header[32] = (byte) (channels * 16 / 8);
        header[33] = 0;
        //每个样本的数据位数
        header[34] = 16;
        header[35] = 0;
        //Data chunk
        header[36] = 'd';//data
        header[37] = 'a';
        header[38] = 't';
        header[39] = 'a';
        header[40] = (byte) (totalAudioLen & 0xff);
        header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
        header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
        header[43] = (byte) ((totalAudioLen >> 24) & 0xff);

        return header;
    }

替换和插入音频

1. 计算两个采样点的位置。偏移头部的大小，讲两个采样点之间的数据，替换成想要的音频。
2. 重新写入修改之后的头部。因为数据长度修改。里面的RIFF块ChunkSize和data块的长度由当前的长度做对应修改。

public static void replaceAudioWithSame(Audio srcAudio, Audio coverAudio, Audio outAudio, float srcStartTime) {

        String srcWavePath = srcAudio.getPath();
        String coverWavePath = coverAudio.getPath();
        int sampleRate = srcAudio.getSampleRate();
        int channels = srcAudio.getChannel();
        int bitNum = srcAudio.getBitNum();
        RandomAccessFile srcFis = null;
        RandomAccessFile coverFis = null;
        RandomAccessFile newFos = null;
        String tempOutPcmPath = srcWavePath + ".tempPcm";
        try {

            //创建输入流
            srcFis = new RandomAccessFile(srcWavePath, "rw");
            coverFis = new RandomAccessFile(coverWavePath, "rw");
            newFos = new RandomAccessFile(tempOutPcmPath, "rw");

            int srcHeadSize = getHeadSize(srcFis);
            int coverHeadSize = getHeadSize(coverFis);

            final int srcStartPos = getPositionFromWave(srcStartTime, sampleRate, channels, bitNum);
            final int coverStartPos = 0;
            final int coverEndPos = (int) coverFis.length() - coverHeadSize;


            //复制源音频srcStartTime时间之前的数据
            //跳过头文件数据
            srcFis.seek(srcHeadSize);

            copyData(srcFis, newFos, srcStartPos);

            //复制覆盖音频指定时间段的数据
            //跳过指定位置数据
            coverFis.seek(coverHeadSize + coverStartPos);

            int copyCoverSize = coverEndPos - coverStartPos;
            float volume = coverAudio.getVolume();
            copyData(coverFis, newFos, copyCoverSize);

            //复制srcStartTime时间后的源文件数据
            final int srcStartAddCoverPosition = getPositionFromWave(srcStartTime + ((float) coverAudio.getTimeMillis()) / 1000, sampleRate, channels, bitNum);

            final long srcFileSize = srcFis.length() - srcHeadSize;
            int remainSize = (int) (srcFileSize - srcStartAddCoverPosition);
            if (remainSize > 0) {

//                coverFis.seek(WAVE_HEAD_SIZE + coverStartPos);
                srcFis.seek(srcHeadSize + srcStartAddCoverPosition);
                copyData(srcFis, newFos, remainSize);

            }

        } catch (Exception e) {
            e.printStackTrace();

            return;

        } finally {
            //关闭输入流
            if (srcFis != null) {
                try {
                    srcFis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (coverFis != null) {
                try {
                    coverFis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (newFos != null) {
                try {
                    newFos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        // 删除源文件,
//        new File(srcWavePath).delete();
        // 转换临时文件为源文件
        AudioEncodeUtil.convertPcm2Wav(tempOutPcmPath, outAudio.getPath(), sampleRate, channels, bitNum);
        //删除临时文件
        new File(tempOutPcmPath).delete();
    }