1 音频采集流程

声音是由物体振动产生的声波，是通过介质（空气或固体、液体）传播并能被人或动物听觉器官所感知的波动现象。声波是一种在时间和振幅上连续的模拟量，麦克风就是一种采集声波并将其转换成模拟电压信号输出的装置，有了声波的模拟电压信号，下一步需要将模拟信号数字化，即将模拟信号通过模数转换器（A/D）后转换成数字信号，最常见的模数转换方式就是脉冲编码调制PCM（Pulse Code Modulation），PCM编码过程如下图所示：

PCM编码过程

从上图中可以看到PCM编码主要有三个过程：采样、量化、编码。

1> 采样
将时间连续的模拟信号按照采样率提取样值，变为时间轴上离散的抽样信号的过程。采样率是每秒从模拟信号中提取样值的次数。Nyquist–Shannon(奈奎斯特-香农)采样定律表明如果至少以模拟信号最高频率2倍的采样率对模拟信号进行均匀采样，那么原始模拟信号才能不失真的从采样产生的离散值中完全恢复。人耳可以听到的声波频率范围是 20Hz～22.05kHz，因此44.1kHz/16bit的音频数据被认为是无损音频。

2> 量化
抽样信号虽然是时间轴上离散的信号，但仍然是模拟信号，其样值在一定的取值范围内，可有无限多个值。显然，对无限个样值给出数字码组来对应是不可能的。为了实现以数字码表示样值，必须采用“四舍五入”的方法把样值分级“取整”，使一定取值范围内的样值由无限多个值变为有限个值。这一过程称为量化。

量化后的抽样信号与量化前的抽样信号相比较，当然有所失真，且不再是模拟信号。这种量化失真在接收端还原模拟信号时表现为噪声，并称为量化噪声。量化噪声的大小取决于把样值分级“取整”的方式，分的级数越多，即量化级差或间隔越小，量化噪声也越小。

3> 编码
量化后的抽样信号就转化为按抽样时序排列的一串十进制数字码流，即十进制数字信号。简单高效的数据系统是二进制码系统，因此应将十进制数字代码变换成二进制编码。这种把量化的抽样信号变换成给定字长(采样位数)的二进制码流的过程称为编码

经过上面的PCM编码过程得到的数字信号就是 PCM音频数据。

在PCM编码过程中主要用3个参数表现PCM音频数据：采样率、采样位数以及声道数，
其中采样率、采样位数上面已经讲解过，通道数即采集声音的通道数，有单声道（mono）和立体声（双声道stereo）等，声道数越多越能体现声音的空间立体效果。

2 PCM音频数据的存储方式

采集的PCM音频数据是需要保存到本地文件中，如果用单声道采集的，则按时间的先后顺序依次存入，如果是双声道的话则按时间先后顺序交叉地存入，如下图所示：

PCM音频数据存储格式

PCM音频数据一般无法通过播放器直接播放。可以使用ffplay工具进行播放

ffplay -f s16le -ar 44100 -ac 1 -i raw.pcm
参数解释
-f s16le: 设置音频格式为有符号16位小端格式（signed 16 bits little endian）,对应Android中的AudioFormat.ENCODING_PCM_16BIT
-ar 44100 ：设置音频采样率（audiorate）为44100
-ac 1：设置声道数（audiochannels）1，单声道为1，双声道为2
-i raw.pcm ：设置输入的pcm音频文件

通常将PCM音频数据转化为WAVE文件就可以用播放器直接解析播放，WAVE是微软公司专门为Windows开发的一种标准数字音频文件，该文件能记录各种单声道或立体声的声音信息，并能保证声音不失真。它符合资源互换文件格式（RIFF）规范。

RIFF文件（符合RIFF规范的文件）是windows环境下大部分多媒体文遵循的一种文件结构,RIFF文件所包含的数据类型由该文件的扩展名来标识，能以RIFF文件存储的数据包括：音频视频交错格式数据（.AVI)、 波形格式数据（.WAV) 、位图格式数据（.RDI)、 MIDI格式数据（.RMI)、调色板格式（.PAL)、多媒体电影（.RMN)、动画光标（.ANI)等，RIFF文件结构如下图所示：

RIFF文件结构
如上图所示，chunk是构成RIFF文件的基本单元，RIFF文件是由chunk嵌套构成，RIFF文件首先存放的必须是一个RIFF chunk，并且只能有这一个标志为RIFF的chunk。chunk的详细说明如下：

ID: 块的唯一标识，其值可为RIFF,LIST,fmt,fact,data等。
Size: 块中Data的大小，以字节为单位。
Data: 块中的实际数据。

只有ID为RIFF或者LIST的chunk才能包含其他的chunk，ID为RIFF的chunk中Data的起始位置的FormType用于标识Data中的chunk的数据类型。

WAVE文件中chunk的排列方式依次是：RIFF chunk（FormType 为 WAVE），Format sub-chunk，Fact sub-chunk（附加块，可选，采用压缩编码的WAVE文件，必须要有Fact chunk，该块中只有一个数据，为每个声道的采样总数），Data chunk。接下来我们看看WAVE文件结构，如下图所示：

WAV音频文件结构

Data sub-chunk中的Data中存放具体的音频数据，将PCM音频数据转换成WAV音频文件实际上就是把PCM音频数据放到该位置。

3 Android上采集和播放PCM音频数据

有了上面的理论基础，接下来就在Android手机上实现一下，使用AudioRecord采集PCM音频数据的代码实现：

private var audioRecord: AudioRecord? = null
private const val sampleRateInHz: Int = 44100
private const val bitsPerSample: Int = 16
private const val channelConfig = AudioFormat.CHANNEL_IN_MONO
private const val audioFormat = AudioFormat.ENCODING_PCM_16BIT
private val bufferSize =
    AudioRecord.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat)

private var pcmFile: File? = null
private var mScope: CoroutineScope? = null

/**
 * 创建音频录制器
 *
 * @author cytmxk
 * @since 2021/10/12
 */
private fun createAudioRecord(): AudioRecord {
    Log.d(TAG, "createAudioRecord: bufferSize = $bufferSize");

    // audioSource: 音频来源，MediaRecorder.AudioSource.MIC 代表来源于麦克风
    // sampleRateInHz: 采样率，每秒取得声音样本的次数，采样频率越高，声音的质量也就越好，还原的声音就越真实，但同时它占用的资源越多。常见的采样率为44100 即44.1KHZ
    // channelConfig: 声道配置，分为单声道和立体声道，CHANNEL_IN_MONO代表单声道，CHANNEL_IN_STEREO代表立体声道
    // audioFormat: 音频格式，ENCODING_PCM_16BIT代表通过PCM进行采样编码，采样的大小为16位
    // bufferSizeInBytes: 音频采集缓冲区大小，计算公式为 采样率 x 位宽 x 采样时间 x 通道数，采样时间一般取 2.5ms~120ms 之间，
    // 由厂商或者具体的应用决定，采样时间取得越短碎片化的数据也就会越多，开发中使用getMinBufferSize()方法的返回值，
    // 使用比getMinBufferSize()小的值则会导致初始化失败。
    return AudioRecord(
        MediaRecorder.AudioSource.MIC, sampleRate,
        channelConfig, audioFormat,
        bufferSize
    )
}

/**
 * 开始音频录制
 *
 * @author cytmxk
 * @since 2021/10/12
 */
public fun startRecord() {
    stopRecord()

    audioRecord = createAudioRecord()
    Log.d(TAG, "captureByAudioRecord: state = ${audioRecord!!.state}")
    // 判断视频录制器是否初始化成功
    if (AudioRecord.STATE_INITIALIZED != audioRecord!!.state) {
        Log.d(TAG, "AudioRecord无法初始化，请检查录制权限或者是否其他app没有释放录音器")
    }

    // 创建用于保存采集的pcm音频数据的文件
    pcmFile = MediaFileUtils.getAudioFile("test.pcm")
    Log.d(TAG, "initPCMFile: pcmFile=$pcmFile")
    pcmFile ?: return

    if (pcmFile!!.exists()) {
        pcmFile!!.delete()
    }

    // 开始采集pcm音频数据
    val buffer = ByteArray(bufferSize)
    audioRecord!!.startRecording()

    // 在IO线程中采集pcm音频数据
    GlobalScope.launch(Dispatchers.IO) {
        mScope = this
        var fileOutputStream: FileOutputStream? = null
        try {
            fileOutputStream = FileOutputStream(pcmFile)
            while (isActive) {
                val readStatus = audioRecord!!.read(buffer, 0, bufferSize)
                Log.d(TAG, "scope: readStatus = $readStatus")
                fileOutputStream.write(buffer)
            }
        } catch (exception: IOException) {
            Log.d(TAG, "scope: exception = $exception")
        } finally {
            fileOutputStream?.also {
                try {
                    it.close()
                } catch (exception: IOException) {
                }
            }
        }
    }
}

/**
 * 暂停音频录制
 *
 * @author cytmxk
 * @since 2021/10/12
 */
public fun stopRecord() {
    mScope ?: return

    mScope!!.cancel()
    mScope = null

    if (AudioRecord.STATE_UNINITIALIZED != audioRecord!!.state) {
        audioRecord!!.stop()
        // 调用release方法之后该对象不可以再次被使用,因此必须将该对象置null
        audioRecord!!.release()
        audioRecord = null
    }
}

上面的代码都有注释，就不在这里详细讲解了，执行完成之后会生成一个用于保存PCM音频数据的test.pcm文件。

为了让手机上的播放器可以播放采集的PCM音频数据，那么接下来通过下面的代码就可将test.pcm文件中保存的PCM音频数据转换成WAVE文件格式并且保存到convert.wav文件中：

private fun convertPcmToWav() {
    val wavFile = MediaFileUtils.getAudioFile("convert.wav")
    wavFile ?: return

    if (wavFile.exists()) {
        wavFile.delete()
    }

    var fileInputStream: FileInputStream? = null
    var fileOutputStream: FileOutputStream? = null
    try {
        fileInputStream = FileInputStream(pcmFile)
        fileOutputStream = FileOutputStream(wavFile)
        val audioByteLen = fileInputStream.channel.size()
        val wavByteLen = audioByteLen + 36
        addWavHeader(fileOutputStream, audioByteLen, wavByteLen)
        val buffer = ByteArray(bufferSize)
        while (fileInputStream.read(buffer) != -1) {
            fileOutputStream.write(buffer)
        }
    } catch (e: IOException) {
        e.printStackTrace()
    } finally {
        try {
            fileInputStream?.close()
            fileOutputStream?.close()
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }
}

private fun addWavHeader(
    fileOutputStream: FileOutputStream, audioByteLen: Long, wavByteLen: Long
) {
    val header = ByteArray(44)
    // WAVE chunk
    // header[0] ~ header[3] 内容为"RIFF"
    header[0] = 'R'.code.toByte()
    header[1] = 'I'.code.toByte()
    header[2] = 'F'.code.toByte()
    header[3] = 'F'.code.toByte()
    // header[4] ~ header[7] 存储文件的字节数（不包含ChunkID和ChunkSize这8个字节）
    header[4] = (wavByteLen and 0xff).toByte()
    header[5] = (wavByteLen shr 8 and 0xff).toByte()
    header[6] = (wavByteLen shr 16 and 0xff).toByte()
    header[7] = (wavByteLen shr 24 and 0xff).toByte()
    // header[8] ~ header[11] 内容为"WAVE"
    header[8] = 'W'.code.toByte()
    header[9] = 'A'.code.toByte()
    header[10] = 'V'.code.toByte()
    header[11] = 'E'.code.toByte()

    // "fmt " 子chunk 4个字节
    // header[12] ~ header[15] 内容为 "fmt "
    header[12] = 'f'.code.toByte()
    header[13] = 'm'.code.toByte()
    header[14] = 't'.code.toByte()
    header[15] = ' '.code.toByte()
    // header[16] ~ header[19] 存储该子块的字节数（不包含Subchunk1ID和Subchunk1Size这8个字节）
    header[16] = 16
    header[17] = 0
    header[18] = 0
    header[19] = 0
    // header[20] ~ header[21] 存储音频文件的编码格式，例如若为PCM则其存储值为1，若为其他非PCM格式的则有一定的压缩。
    header[20] = 1
    header[21] = 0
    // header[22] ~ header[23] 通道数，单通道(CHANNEL_IN_MONO)值为1，双通道(CHANNEL_IN_STEREO)值为2
    val channelSize = if (channelConfig == AudioFormat.CHANNEL_IN_MONO) 1 else 2
    header[22] = channelSize.toByte()
    header[23] = 0
    // header[24] ~ header[27] 采样频率
    header[24] = (sampleRateInHz and 0xff).toByte()
    header[25] = (sampleRateInHz shr 8 and 0xff).toByte()
    header[26] = (sampleRateInHz shr 16 and 0xff).toByte()
    header[27] = (sampleRateInHz shr 24 and 0xff).toByte()
    // header[28] ~ header[31] 每秒采集的音频字节数
    val byteRate = (audioFormat * sampleRateInHz * channelSize).toLong()
    header[28] = (byteRate and 0xff).toByte()
    header[29] = (byteRate shr 8 and 0xff).toByte()
    header[30] = (byteRate shr 16 and 0xff).toByte()
    header[31] = (byteRate shr 24 and 0xff).toByte()
    // header[32] ~ header[33] 块对齐大小，每个采样(包含所有声道)需要的字节数
    header[32] = (channelSize * bitsPerSample / 8).toByte()
    header[33] = 0
    // header[34] ~ header[35] 每个采样需要的 bit 数
    header[34] = bitsPerSample.toByte()
    header[35] = 0

    //data 子chunk
    // header[36] ~ header[39] 内容为“data”
    header[36] = 'd'.code.toByte()
    header[37] = 'a'.code.toByte()
    header[38] = 't'.code.toByte()
    header[39] = 'a'.code.toByte()
    // header[40] ~ header[43] pcm字节数
    header[40] = (audioByteLen and 0xff).toByte()
    header[41] = (audioByteLen shr 8 and 0xff).toByte()
    header[42] = (audioByteLen shr 16 and 0xff).toByte()
    header[43] = (audioByteLen shr 24 and 0xff).toByte()
    try {
        fileOutputStream.write(header, 0, 44)
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

通过系统文件夹应用找到convert.wav文件的位置，点击就可以播放了。

其实PCM音频数据也可以直接使用AudioTrack播放，实现代码如下:

private var audioTrack: AudioTrack? = null
private const val sampleRateInHz: Int = 44100
private const val channelConfig = AudioFormat.CHANNEL_OUT_MONO // 错误的写成了CHANNEL_IN_MONO
private const val audioFormat = AudioFormat.ENCODING_PCM_16BIT
private val bufferSize =
    AudioTrack.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat)

private var pcmFile: File? = null
private var mScope: CoroutineScope? = null


public fun playAudioByAudioTrack() {
    pcmFile = MediaFileUtils.getAudioFile("test.pcm")
    Log.d(TAG, "initPCMFile: pcmFile=${pcmFile}")
    pcmFile ?: return

    if (!pcmFile!!.exists()) {
        return
    }

    stopPlayAudio()
    initAudioTrackWithMode(AudioTrack.MODE_STREAM)
    if (audioTrack!!.state == AudioTrack.STATE_UNINITIALIZED) {
        Log.e(TAG, "state is uninit")
        return
    }

    // 在IO线程中播放采集的pcm音频数据
    GlobalScope.launch(Dispatchers.IO) {
        mScope = this
        var fileInputStream: FileInputStream? = null
        try {
            fileInputStream = FileInputStream(pcmFile)
            val buffer = ByteArray(bufferSize / 2)
            //stream模式，可以先调用play
            audioTrack!!.play()
            while (isActive && fileInputStream.available() > 0) {
                val readCount = fileInputStream.read(buffer)
                if (readCount == AudioTrack.ERROR_BAD_VALUE || readCount == AudioTrack.ERROR_INVALID_OPERATION) {
                    continue
                }

                if (readCount > 0 && audioTrack!!.playState == AudioTrack.PLAYSTATE_PLAYING && audioTrack!!.state == AudioTrack.STATE_INITIALIZED) {
                    audioTrack!!.write(buffer, 0, readCount)
                }
            }
        } catch (exception: IOException) {
            Log.d(TAG, "scope: exception = $exception")
        } finally {
            fileInputStream?.also {
                try {
                    it.close()
                } catch (exception: IOException) {
                }
            }
        }
    }
}

private fun initAudioTrackWithMode(mode: Int) {
    audioTrack = AudioTrack(
        AudioAttributes.Builder()
            .setLegacyStreamType(AudioManager.STREAM_MUSIC)
            .build(),
        AudioFormat.Builder()
            .setChannelMask(channelConfig)
            .setEncoding(audioFormat)
            .setSampleRate(sampleRateInHz)
            .build(),
        bufferSize,
        mode, AudioManager.AUDIO_SESSION_ID_GENERATE
    )
}

public fun stopPlayAudio() {
    mScope ?: return
    mScope!!.cancel()

    if (AudioTrack.STATE_UNINITIALIZED != audioTrack!!.state) {
        audioTrack!!.stop()
        audioTrack!!.release()
    }
}

通过执行上面playAudioByAudioTrack方法就可以播放上面生成的test.pcm音频文件。