Android Audio Wav 文件读写操作的封装

66 阅读 0 评论 44 点赞

我是靠谱客的博主美满荷花，最近开发中收集的这篇文章主要介绍Android Audio Wav 文件读写操作的封装，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Android 在使用 AudioRecord 录音时，采集的是 PCM 数据，有时候在录完后向听下录音效果，还需要拉到电脑端用 AU 播放，手机端没法直接播放 PCM 数据。因此封装了一个 WavFile 在 PCM 前面增加 Wav 头，生成 wav 文件，可以在手机上直接播放。文件头信息见：《Audio WAV文件头格式》

使用方法如下：


String wavSavePath = "/sdcard/Alan/audio/record.wav";
// 指定 PCM 格式(跟 AudioRecord 配置一致)，内部自动生成 wav 头信息
WavFile.HeadInfo headInfo = WavFile.HeadInfo.build()
.setSampleRate(44100)
.setChannelCount(1)
.setBytePerSample(2);
WavFile wavFile = new WavFile(wavSavePath, headInfo);
// 录制过程中从 AudioRecord 读到 PCM 数据后写入 wavFile
wavFile.write(byteBuffer.array(), byteBuffer.arrayOffset(), byteBuffer.limit());
// 录制结束关闭文件
wavFile.close();

完整 Demo 见 GitHub

WavFile 封装如下：

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/**
* 封装文件头尾 44 字节长度的 WavFile，支持对 WavFile 的读、写操作，
* 以 {@link #WavFile(String)} 方式创建时，为[读]模式，可以通过 {@link #getHeadInfo()} 获取 wav 文件的头信息
* 以 {@link #WavFile(String, HeadInfo)} 方式创建时，为[写]模式
*
* Author: AlanWang4523.
* Date: 2020/10/28 20:35.
* Mail: alanwang4523@gmail.com
*/
public class WavFile {
private HeadInfo mHeadInfo;
private RandomAccessFile mWavFile;
private int mAudioDataLenInBytes;
private volatile boolean isWriteMode;
private volatile boolean isClosed;
/**
* 构建一个 WavFile，该文件已存在，以读模式打开
* @param filePath wav file 文件路径
* @throws IOException IOException
*/
public WavFile(String filePath) throws IOException {
this(filePath, null);
}
/**
* 根据 HeadInfo 创建一个 WavFile，以写模式打开
* @param filePath wav file 文件路径
* @param wavHeaderInfo wavHeaderInfo
* @throws IOException IOException
*/
public WavFile(String filePath, HeadInfo wavHeaderInfo) throws IOException {
mWavFile = new RandomAccessFile(filePath, "rw");
if (wavHeaderInfo != null) {
mHeadInfo = wavHeaderInfo;
byte[] wavHeader = generateWavHeader(
wavHeaderInfo.getSampleRate(),
wavHeaderInfo.getChannelCount(),
wavHeaderInfo.getBytePerSample() * 8,
0);
mWavFile.write(wavHeader);
isWriteMode = true;
} else {
mHeadInfo = getWavHeader(mWavFile);
isWriteMode = false;
}
mWavFile.seek(44);
mAudioDataLenInBytes = 0;
isClosed = false;
}
/**
* 获取 wav 头信息
* @return HeadInfo
*/
public HeadInfo getHeadInfo() {
return mHeadInfo;
}
/**
* 读取 PCM 数据
* @param data pcm 数据存放的位置
* @param off offset
* @param len 想要读取的长度，单位：字节
* @return 读取的长度，单位：字节
* @throws IOException IOException
*/
public int read(byte[] data, int off, int len) throws IOException {
if (isWriteMode) {
throw new IOException("The current file is not read mode.");
}
if (isClosed) {
return 0;
}
return mWavFile.read(data, off, len);
}
/**
* 写 PCM 数据
* @param data 音频数据
* @param offset offset
* @param len 数据长度，单位：字节
*/
public void write(byte[] data, int offset, int len) throws IOException {
if (!isWriteMode) {
throw new IOException("The current file is not write mode.");
}
if (isClosed || data == null || len <= 0) {
return;
}
mWavFile.write(data, offset, len);
mAudioDataLenInBytes += len;
}
/**
* 更新 wav 文件头信息，并关闭文件
* @throws IOException IOException
*/
public void close() throws IOException {
if (isClosed) {
return;
}
isClosed = true;
// 如果是写入模式，则更新文件头中的数据长度信息
if (isWriteMode) {
int totalFileLenIncludeHeader = mAudioDataLenInBytes + 44;
//更新wav文件头04H— 08H的数据长度：该长度 = 文件总长 - 8
mWavFile.seek(4);
mWavFile.write(int2ByteArray(totalFileLenIncludeHeader - 8));
//更新wav文件头28H— 2CH,实际PCM采样数据长度
mWavFile.seek(40);
mWavFile.write(int2ByteArray(totalFileLenIncludeHeader - 44));
}
mWavFile.close();
}
/**
* 生成 44 字节 WAV 文件头
* @param sampleRate 采样率，如 44100
* @param channels 通道数，如立体声为2
* @param bitsPerSample 采样精度，即每个采样所占数据位数，如 16，表示每个采样 16bit 数据，即 2 个字节
* @param audioDataLenInBytes 音频数据长度
* @return 44 字节 WAV 头信息
*/
private byte[] generateWavHeader(int sampleRate, int channels, int bitsPerSample, int audioDataLenInBytes) {
if (bitsPerSample != 16 && bitsPerSample != 32) {
throw new IllegalArgumentException("The bitsPerSample is not 16 or 32!");
}
if (audioDataLenInBytes < 0) {
throw new IllegalArgumentException("Audio data len could not be negative!");
}
byte[] wavHeader = new byte[44];
// 这个长度不包括"RIFF"标志(4字节)和文件长度本身所占字节(4字节),即该长度等于整个 Wav文件长度(包含44字节头) - 8
// 也等于纯音频数据的长度 + 36
int ckTotalSize = 36 + audioDataLenInBytes;
// 生成文件头默认纯音频数据长度为 0
int audioDataLen = audioDataLenInBytes;
// 音频数据传送速率, 单位是字节。其值为采样率×每次采样大小。播放软件利用此值可以估计缓冲区的大小。
// bytePerSecond = sampleRate * (bitsPerSample / 8) * channels
int bytePerSecond = sampleRate * (bitsPerSample / 8) * channels;
//ckid：4字节 RIFF 标志，大写
wavHeader[0]
= 'R';
wavHeader[1]
= 'I';
wavHeader[2]
= 'F';
wavHeader[3]
= 'F';
//cksize：4字节文件长度，这个长度不包括"RIFF"标志(4字节)和文件长度本身所占字节(4字节),即该长度等于整个文件长度 - 8
wavHeader[4]
= (byte)(ckTotalSize & 0xff);
wavHeader[5]
= (byte)((ckTotalSize >> 8) & 0xff);
wavHeader[6]
= (byte)((ckTotalSize >> 16) & 0xff);
wavHeader[7]
= (byte)((ckTotalSize >> 24) & 0xff);
//fcc type：4字节 "WAVE" 类型块标识, 大写
wavHeader[8]
= 'W';
wavHeader[9]
= 'A';
wavHeader[10] = 'V';
wavHeader[11] = 'E';
//ckid：4字节 表示"fmt" chunk的开始,此块中包括文件内部格式信息，小写, 最后一个字符是空格
wavHeader[12] = 'f';
wavHeader[13] = 'm';
wavHeader[14] = 't';
wavHeader[15] = ' ';
//cksize：4字节，文件内部格式信息数据的大小，过滤字节（一般为00000010H）
wavHeader[16] = 0x10;
wavHeader[17] = 0;
wavHeader[18] = 0;
wavHeader[19] = 0;
//FormatTag：2字节，音频数据的编码方式，1：表示是PCM 编码
wavHeader[20] = 1;
wavHeader[21] = 0;
//Channels：2字节，声道数，单声道为1，双声道为2
wavHeader[22] = (byte) channels;
wavHeader[23] = 0;
//SamplesPerSec：4字节，采样率，如44100
wavHeader[24] = (byte)(sampleRate & 0xff);
wavHeader[25] = (byte)((sampleRate >> 8) & 0xff);
wavHeader[26] = (byte)((sampleRate >> 16) & 0xff);
wavHeader[27] = (byte)((sampleRate >> 24) & 0xff);
//BytesPerSec：4字节，音频数据传送速率, 单位是字节。其值为采样率×每次采样大小。播放软件利用此值可以估计缓冲区的大小；
//bytePerSecond = sampleRate * (bitsPerSample / 8) * channels
wavHeader[28] = (byte)(bytePerSecond & 0xff);
wavHeader[29] = (byte)((bytePerSecond >> 8) & 0xff);
wavHeader[30] = (byte)((bytePerSecond >> 16) & 0xff);
wavHeader[31] = (byte)((bytePerSecond >> 24) & 0xff);
//BlockAlign：2字节，每次采样的大小 = 采样精度*声道数/8(单位是字节); 这也是字节对齐的最小单位, 譬如 16bit 立体声在这里的值是 4 字节。
//播放软件需要一次处理多个该值大小的字节数据，以便将其值用于缓冲区的调整
wavHeader[32] = (byte)(bitsPerSample * channels / 8);
wavHeader[33] = 0;
//BitsPerSample：2字节，每个声道的采样精度; 譬如 16bit 在这里的值就是16。如果有多个声道，则每个声道的采样精度大小都一样的；
wavHeader[34] = (byte) bitsPerSample;
wavHeader[35] = 0;
//ckid：4字节，数据标志符（data），表示 "data" chunk的开始。此块中包含音频数据，小写；
wavHeader[36] = 'd';
wavHeader[37] = 'a';
wavHeader[38] = 't';
wavHeader[39] = 'a';
//cksize：音频数据的长度，4字节，audioDataLen = ckSize - 36 = fileLenIncludeHeader - 44
wavHeader[40] = (byte)(audioDataLen & 0xff);
wavHeader[41] = (byte)((audioDataLen >> 8) & 0xff);
wavHeader[42] = (byte)((audioDataLen >> 16) & 0xff);
wavHeader[43] = (byte)((audioDataLen >> 24) & 0xff);
return wavHeader;
}
/**
* 从 wav 文件中获取头信息
* 注意：必须是 44 字节头的 wav 文件
* @param randomAccessFile wav 文件
* @return HeadInfo
* @throws IOException IOException
*/
private HeadInfo getWavHeader(RandomAccessFile randomAccessFile) throws IOException {
//读取channelCount，第22~23位
randomAccessFile.seek(22);
byte[] channelCountArray = new byte[2];
randomAccessFile.read(channelCountArray);
int channelCount = byteArray2Short(channelCountArray);
//读取sampleRate，第24~27位
randomAccessFile.seek(24);
byte[] sampleRateArray = new byte[4];
randomAccessFile.read(sampleRateArray);
int sampleRate = byteArray2Int(sampleRateArray);
//读取BitsPerSample，第34~35位
randomAccessFile.seek(34);
byte[] bitsPerSampleArray = new byte[2];
randomAccessFile.read(bitsPerSampleArray);
int bytePerSample = byteArray2Short(bitsPerSampleArray) / 8;
return HeadInfo.build().
setSampleRate(sampleRate).
setChannelCount(channelCount).
setBytePerSample(bytePerSample);
}
/**
* 将 byte 数组转成short
* @param b byte 数组
* @return 返回 short 数值
*/
private static short byteArray2Short(byte[] b) {
return ByteBuffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).getShort();
}
/**
* 将整型转成 byte 数组
* @param data 要转换的数字
* @return byte 数组
*/
private static byte[] int2ByteArray(int data) {
return ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(data).array();
}
/**
* 将 byte 数组转成整型
* @param b byte 数组
* @return int 数值
*/
private static int byteArray2Int(byte[] b) {
return ByteBuffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).getInt();
}
public static class HeadInfo {
/**
* 采样率
*/
private int sampleRate;
/**
* 通道数
*/
private int channelCount;
/**
* 每个采样点的大小，
* short 型 PCM 是 2 字节
* float 型 PCM 是 4 字节
* 单位：字节
*/
private int bytePerSample = 2;
/**
* 构造 HeadInfo
* @return HeadInfo 实例
*/
public static HeadInfo build() {
return new HeadInfo();
}
/**
* 获取音频采样率，如：44100、48000
* @return 设置参数后的 HeadInfo 实例
*/
public int getSampleRate() {
return sampleRate;
}
/**
* 设置音频采样率
* @param sampleRate 采样率，如：44100、48000
* @return 设置参数后的 HeadInfo 实例
*/
public HeadInfo setSampleRate(int sampleRate) {
this.sampleRate = sampleRate;
return this;
}
/**
* 获取音频通道数，如：1、2
* @return 设置参数后的 HeadInfo 实例
*/
public int getChannelCount() {
return channelCount;
}
/**
* 设置音频通道数
* @param channelCount 音频通道数
* @return 设置参数后的 HeadInfo 实例
*/
public HeadInfo setChannelCount(int channelCount) {
this.channelCount = channelCount;
return this;
}
/**
* 获取每个采样点大小，单位：字节
* short 型 PCM 是 2 字节
* float 型 PCM 是 4 字节
* @return 每个采样点占的字节数
*/
public int getBytePerSample() {
return bytePerSample;
}
/**
* 设置每个采样占的字节数
* @param bytePerSample bytePerSample
* @return 设置参数后的 HeadInfo 实例
*/
public HeadInfo setBytePerSample(int bytePerSample) {
this.bytePerSample = bytePerSample;
return this;
}
}
}