本篇先从概念上剖析了整个音频处理流程：采样-量化-编码-压缩编码。然后通过实例代码，分析如何使用 AudioRecord & MediaRecorder 在安卓手机上录制音频的详细过程。
基础知识
模拟信号
音频承载着声音信息，而声音是连续变化的信息。物理中把承载信息的载体称为信号，把连续变化的信息称为模拟信号，它在坐标轴中表现为如下形态：
计算机只能处理0和1，即离散值。音频这种模拟信号得转换成离散值才能被计算机处理。这个转化过程称为模拟信号数字化，分为三个步骤：
1. 采样
采样是对连续信号在时间上进行离散，即按照特定的时间间隔在原始的模拟信号上逐点采集瞬时值。采样的可视化效果如下图所示：
原本连续的曲线被一根根离散的竖直线条代替。这些线条越密集，将它们相连后形成的曲线就越接近原始模拟信号。
物理中用采样频率来表示采样的密集程度，即每秒采样次数(采样数/秒)，它用赫兹（Hz）表示
2. 量化
虽然连续值已被采样成若干离散值，但每个离散值的取值可能有无限多个。为了给每一个离散值都对应一个数字码，必须将无限种取值转化为有限种取值（对于只能处理二进制的计算机来说，取值的可能数应该是2的倍数）。物理中把这种通过四舍五入分级取整的方法称为量化。量化后的数字信号如下图所示：
量化后的音频变得死板有棱角，就好像人类和机器人的差别。
3. 编码
模拟信号经过采样变成离散值，每一个离散值经过量化都对应一个二进制，将这些二进制按时间序列组合在一起就称为编码。
经过采样量化编码形成的是音频的原始数据，这种原始数据格式称为PCM（Pulse Code Modulation），即是采样量化编码的英文表示。
.pcm 后缀的文件是非常非常大的，这增加了存储和网络传输的成本。遂 PCM 这样原始的无损音频还得经过一次压缩编码。
音频存在冗余信息，才能被压缩。比如人耳能辨识的声音频率范围为20Hz～20KHz，该频率以外的声音都是冗余信息。再比如强弱信号同时出现，强弱差距过大，以至于弱信号完全被掩盖，弱信号就是冗余信息。
音频有很多压缩编码的格式，以下是 Android 官方支持的格式：
在移动端最为常用的格式是 AAC，即 Advanced Audio Coding，是一种专为声音数据设计的文件压缩格式。它采用了更加高效的编码方式，使得它拥有和 MP3 相当的音质及更小的体积。
压缩编码由两种执行方式，交由 GPU 或是 CPU 执行，前者称为硬编码后者称为软编码，硬编码速度快，但兼容差，会存在编码失败的情况。软编码速度慢，但兼容性好。
录制 PCM 音频
Android 提供了两种录制音频的方式：1. MediaRecorder 2. AudioRecord
如果没有优化音频的需求，完全可以使用 MediaRecorder 直接输出 AAC 格式的音频。
而音频优化，比如降噪，增益算法都是基于 PCM 格式的。这就不得不使用 AudioRecord 来录制音频。
构建 AudioRecord 对象
AudioRecord 的构造函数包含 6 个参数：
- 音频源：表示从哪里采集音频，通常是麦克风。
- 采样频率：即每秒钟采用次数，44100 Hz是目前所有安卓设备都支持的采样频率。
- 声道数：表示声音由几个声道组成，单声道是目前所有安卓设备都支持的声道数。
- 量化精度：表示采用多少位二进制来表达一次量化的离散值，通常用 16 位。
- 缓冲区大小：表示在内存开辟一块多大的缓冲区用于存放硬件采集的音频数据。
构建 AudioRecord 的模板代码如下：
const val SOURCE = MediaRecorder.AudioSource.MIC //通过麦克风采集音频
const val SAMPLE_RATE = 44100 // 采样频率为 44100 Hz
const val CHANNEL_IN_MONO = AudioFormat.CHANNEL_IN_MONO // 单声道
const val ENCODING_PCM_16BIT = AudioFormat.ENCODING_PCM_16BIT //量化精度为 16 位
var bufferSize: Int = 0 // 音频缓冲区大小
val audioRecord by lazy {
// 计算缓冲区大小
bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT)
// 构建 AudioRecord 实例
AudioRecord(SOURCE, SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT, bufferSize)
}
复制代码将构建 AudioRecord 的参数都常量化，以便在其他地方引用。其中缓冲区大小是通过AudioRecord.getMinBufferSize()动态计算的，计算的依据是采样平率、声道数、量化精度。
读取音频数据写入文件
有了 AudioRecord 实例，就可以调用它的方法从硬件设备中读取音频数据了。它提供了 3 个方法来控制音频数据的读取，分别是开始录制startRecording()、读一批音频数据read()、停止录制stop()，这 3 个方法通常用下面的模板来组合：
audioRecord.startRecording()
while(是否继续录制){ audioRecord.read() }
audioRecord.stop()
复制代码音频数据的大小以字节为单位，音频数据的读取是一批一批进行的，所以需要一个 while 循环持续不断地读取，每次读取多少字节由申请的缓冲区大小决定。
从硬件设备读取的音频字节先存放在字节数组中，然后再把字节数组写入文件就形成了 PCM 文件：
var bufferSize: Int = 0 // 音频缓冲区大小
val outputFile:File // pcm 文件
val audioRecord: AudioRecord
// 构建 pcm 文件输出流
outputFile.outputStream().use { outputStream ->
// 开始录制
audioRecord.startRecording()
// 构建存放音频数据的字节数组
val audioData = ByteArray(bufferSize)// 对应 java 中的 byte[]
// 持续读取音频数据
while (continueRecord()) {
// 读一批音频数据到字节数组
audioRecord.read(audioData, 0, audioData.size)
// 将字节数组通过输出流写入 pcm 文件
outputStream.write(audioData)
}
// 停止录制
audioRecord.stop()
}
复制代码- 其中
outputStream()是 File 的一个扩展方法，它使得代码语音更清晰，更连续：
public inline fun File.outputStream(): FileOutputStream {
return FileOutputStream(this)
}
复制代码use()是一个 Closeable 的扩展方法，不管发生了什么，最终use()都会调用close()来关闭资源。这就避免了流操作的模板代码，降低了代码的复杂度：
public inline fun <T : Closeable?, R> T.use(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
var exception: Throwable? = null
try {
// 在 try 代码块中执行传入的 lambda
return block(this)
} catch (e: Throwable) {
exception = e
throw e
} finally {
// 在 finally 中执行 close()
when {
apiVersionIsAtLeast(1, 1, 0) -> this.closeFinally(exception)
this == null -> {}
exception == null -> close()
else ->
try {
close()
} catch (closeException: Throwable) {}
}
}
}
复制代码- IO操作时耗时的，读写音频数据的代码应该在非UI线程中执行。而是否继续录制应该由用户动作触发，即UI线程触发。这里有多线程安全问题，需要一个线程安全的布尔值来控制音频录制：
var isRecording = AtomicBoolean(false) // 线程安全的布尔变量
val audioRecord: AudioRecord
// 是否继续录制
fun continueRecord(): Boolean {
return isRecording.get() &&
audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING
}
// 停止录制音频(供业务层调用以停止录音的 while 循环)
fun stop() {
isRecording.set(false)
}
复制代码解耦抽象
将对 AudioRecord 的所有操作都抽象在一个接口中：
interface Recorder {
var outputFormat: String // 输出音频格式
fun isRecording(): Boolean // 是否正在录制
fun getDuration(): Long // 获取音频时长
fun start(outputFile: File, maxDuration: Int) // 开始录制
fun stop() // 停止录制
fun release() // 释放录制资源
}
复制代码这个接口提供了录制音频的抽象能力。当上层类和这组接口打交道时，不需要关心录制音频的实现细节，即不和 AudioRecord 耦合。
为啥要多一层这样的抽象？因为具体实现总是易变的，万一哪天业务层需要直接生成 AAC 文件，就可以通过添加一个Recorder的实例方便地地替换原有实现。
给出 AudioRecord 对于Recorder接口的实现：
class AudioRecorder(override var outputFormat: String) : Recorder {
private var bufferSize: Int = 0 // 音频字节缓冲区大小
private var isRecording = AtomicBoolean(false) // 用于控制音频录制的线程安全布尔值
private var startTime = 0L // 记录音频开始录制时间
private var duration = 0L // 音频时长
// AudioRecord 实例
private val audioRecord by lazy {
bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT)
AudioRecord(SOURCE, SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT, bufferSize)
}
// 是否正在录制
override fun isRecording(): Boolean = isRecording.get()
// 获取音频时长
override fun getDuration(): Long = duration
// 开始音频录制
override fun start(outputFile: File, maxDuration: Int) {
if (audioRecord.state == AudioRecord.STATE_UNINITIALIZED) return
isRecording.set(true) // 在异步线程中标记开始录制
startTime.set(SystemClock.elapsedRealtime()) // 在异步线程中记录开始时间
// 创建文件输出流
outputFile.outputStream().use { outputStream ->
// 开始录制
audioRecord.startRecording()
val audioData = ByteArray(bufferSize)
// 持续读取音频数据到字节数组, 再将字节数组写入文件
while (continueRecord(maxDuration)) {
audioRecord.read(audioData, 0, audioData.size)
outputStream.write(audioData)
}
// 循环结束后通知底层结束录制
if (audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING) {
audioRecord.stop()
}
// 如果录音长度超过最大时长,则回调给上层
if (duration >= maxDuration) handleRecordEnd(isSuccess = true, isReachMaxTime = true)
}
}
// 判断录音是否可以继续
private fun continueRecord(maxDuration: Int): Boolean {
// 实时计算录音时长
duration = SystemClock.elapsedRealtime() - startTime.get()
return isRecording.get() &&
audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING &&
duration < maxDuration
}
// 停止录音(在UI线程调用)
override fun stop() {
isRecording.set(false)
}
// 释放录音资源
override fun release() {
audioRecord.release()
}
}
复制代码下面是 MediaRecorder 对于Recorder接口的实现：
inner class MediaRecord(override var outputFormat: String) : Recorder {
private var starTime = AtomicLong() // 音频录制开始时间
// 监听录制是否超时的回调
private val listener = MediaRecorder.OnInfoListener { _, what, _ ->
when (what) {
MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED -> {
// 如果录制超时,则停止录制会回调上层
stop()
handleRecordEnd(isSuccess = true, isReachMaxTime = true)
}
else -> {
handleRecordEnd(isSuccess = false, isReachMaxTime = false)
}
}
}
// 录制错误监听器
private val errorListener = MediaRecorder.OnErrorListener { _, _, _ ->
handleRecordEnd(isSuccess = false, isReachMaxTime = false)
}
private val recorder = MediaRecorder()
private var isRecording = AtomicBoolean(false) // 用于控制音频录制的线程安全布尔值
private var duration = 0L // 音频时长
// 判断是否正在录制音频
override fun isRecording(): Boolean = isRecording.get()
// 录制音频时长
override fun getDuration(): Long = duration
// 开始录制音频
override fun start(outputFile: File, maxDuration: Int) {
// 枚举音频输出格式
val format = when (outputFormat) {
AMR -> MediaRecorder.OutputFormat.AMR_NB
else -> MediaRecorder.OutputFormat.AAC_ADTS
}
// 枚举音频编码格式
val encoder = when (outputFormat) {
AMR -> MediaRecorder.AudioEncoder.AMR_NB
else -> MediaRecorder.AudioEncoder.AAC
}
// 开始录制
starTime.set(SystemClock.elapsedRealtime())
isRecording.set(true)
recorder.apply {
reset()
setAudioSource(MediaRecorder.AudioSource.MIC)
setOutputFormat(format)
setOutputFile(outputFile.absolutePath)
setAudioEncoder(encoder)
setOnInfoListener(listener)
setOnErrorListener(errorListener)
setMaxDuration(maxDuration)
prepare()
start()
}
}
// 停止录制
override fun stop() {
recorder.stop()
isRecording.set(false)
duration = SystemClock.elapsedRealtime() - starTime.get()
}
// 释放录制资源
override fun release() {
recorder.release()
}
}
复制代码把和Recorder接口打交道的上层类定义为AudioManager，它是业务层访问音频能力的入口，提供了一组访问接口：
// 构造 AudioManager 时需传入上下文和音频输出格式
class AudioManager(val context: Context, val type: String = AAC) {
companion object {
const val AAC = "aac"
const val AMR = "amr"
const val PCM = "pcm"
}
private var maxDuration = 120 * 1000 // 默认最大音频时长为 120 s
// 根据输出格式实例化对应 Recorder 实例
private var recorder: Recorder = if (type == PCM) AudioRecorder(type) else MediaRecord(type)
// 开始录制
fun start(maxDuration: Int = 120) {
this.maxDuration = maxDuration * 1000
startRecord()
}
// 停止录制
fun stop(cancel: Boolean = false) {
stopRecord(cancel)
}
// 释放资源
fun release() {
recorder.release()
}
// 是否正在录制
fun isRecording() = recorder.isRecording()
}
复制代码其中的startRecord()和stopRecord()包含了AudioManager层控制播放的逻辑：
class AudioManager(val context: Context, val type: String = AAC) :
// 为了方便启动协程录制,直接继承 CoroutineScope,并调度协程到一个单线程线程池对应的 Dispatcher
CoroutineScope by CoroutineScope(SupervisorJob() + Executors.newFixedThreadPool(1).asCoroutineDispatcher()) {
private var recorder: Recorder = if (type == PCM) AudioRecorder(type) else MediaRecord(type)
// 开始录制
private fun startRecord() {
// 请求音频焦点
audioManager.requestAudioFocus(null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
// 若音频正在录制,则返回
if (recorder.isRecording()) {
setState(STATE_FAILED) // 设置状态为失败
return
}
// 如果储存卡控件不足,则返回
if (getFreeSpace() <= 0) {
setState(STATE_FAILED) // 设置状态为失败
return
}
// 创建音频文件
audioFile = getAudioFile()
// 若创建失败,则返回
if (audioFile == null) setState(STATE_FAILED) // 设置状态为失败
cancelRecord.set(false)
try {
if (! cancelRecord.get()) {
setState(STATE_READY) // 设置状态为就绪
if (hasPermission()) { // 拥有录制和存储权限
// 启动协程开始录制
launch { recorder.start(audioFile !!, maxDuration) }
setState(STATE_START) // 设置状态为开始
} else {
stopRecord(false) // 没有权限则停止录制
}
}
} catch (e: Exception) {
e.printStackTrace()
stopRecord(false) // 发生异常时,停止录制
}
}
// 停止录制,需传入是否是用户主动取消录制
private fun stopRecord(cancel: Boolean) {
// 若不在录制中,则返回
if (! recorder.isRecording()) {
return
}
cancelRecord.set(cancel)
// 放弃音频焦点
audioManager.abandonAudioFocus(null)
try {
// 停止录音
recorder.stop()
} catch (e: Exception) {
e.printStackTrace()
} finally {
// 录音结束后,回调状态
handleRecordEnd(isSuccess = true, isReachMaxTime = false)
}
}
}
复制代码因为AudioManager是和业务层打交道的类，所以这一层就多了些零碎的控制逻辑，包括音频焦点的获取、存储和录音权限的判断、创建时声音文件、录音状态的回调。
其中录音状态的回调被定义成了若干个 lambda：
class AudioManager(val context: Context, val type: String = AAC) :
CoroutineScope by CoroutineScope(SupervisorJob() + Executors.newFixedThreadPool(1).asCoroutineDispatcher()) {
// 状态常量
private val STATE_FAILED = 1
private val STATE_READY = 2
private val STATE_START = 3
private val STATE_SUCCESS = 4
private val STATE_CANCELED = 5
private val STATE_REACH_MAX_TIME = 6
// 主线程 Handler,用于将状态回调在主线程
private val callbackHandler = Handler(Looper.getMainLooper())
// 将录音状态回调给业务层的 lambda
var onRecordReady: (() -> Unit)? = null
var onRecordStart: ((File) -> Unit)? = null
var onRecordSuccess: ((File, Long) -> Unit)? = null
var onRecordFail: (() -> Unit)? = null
var onRecordCancel: (() -> Unit)? = null
var onRecordReachedMaxTime: ((Int) -> Unit)? = null
// 状态变更
private fun setState(state: Int) {
callbackHandler.post {
when (state) {
STATE_FAILED -> onRecordFail?.invoke()
STATE_READY -> onRecordReady?.invoke()
STATE_START -> audioFile?.let { onRecordStart?.invoke(it) }
STATE_CANCELED -> onRecordCancel?.invoke()
STATE_SUCCESS -> audioFile?.let { onRecordSuccess?.invoke(it, recorder.getDuration()) }
STATE_REACH_MAX_TIME -> onRecordReachedMaxTime?.invoke(maxDuration)
}
}
}
}
复制代码将状态分发回调的细节分装在setState()方法中，以降低录音流程控制代码的复杂度。
完整的AudioManager代码如下：
import android.content.Context
import android.content.pm.PackageManager
import android.media.AudioFormat
import android.media.AudioFormat.CHANNEL_IN_MONO
import android.media.AudioFormat.ENCODING_PCM_16BIT
import android.media.AudioManager
import android.media.AudioRecord
import android.media.MediaRecorder
import android.os.*
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.asCoroutineDispatcher
import kotlinx.coroutines.launch
import java.io.File
import java.util.*
import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicLong
/**
* provide the ability to record audio in file.
* [AudioManager] exists for the sake of the following:
* 1. launch a thread to record audio in file.
* 2. control the state of recording and invoke according callbacks in main thread.
* 3. provide interface for the business layer to control audio recording
*/
class AudioManager(val context: Context, val type: String = AAC) :
CoroutineScope by CoroutineScope(SupervisorJob() + Executors.newFixedThreadPool(1).asCoroutineDispatcher()) {
companion object {
const val AAC = "aac"
const val AMR = "amr"
const val PCM = "pcm"
const val SOURCE = MediaRecorder.AudioSource.MIC
const val SAMPLE_RATE = 44100
const val CHANNEL = 1
}
private val STATE_FAILED = 1
private val STATE_READY = 2
private val STATE_START = 3
private val STATE_SUCCESS = 4
private val STATE_CANCELED = 5
private val STATE_REACH_MAX_TIME = 6
/**
* the callback business layer cares about
*/
var onRecordReady: (() -> Unit)? = null
var onRecordStart: ((File) -> Unit)? = null
var onRecordSuccess: ((File, Long) -> Unit)? = null// deliver audio file and duration to business layer
var onRecordFail: (() -> Unit)? = null
var onRecordCancel: (() -> Unit)? = null
var onRecordReachedMaxTime: ((Int) -> Unit)? = null
/**
* deliver recording state to business layer
*/
private val callbackHandler = Handler(Looper.getMainLooper())
private var maxDuration = 120 * 1000
private var recorder: Recorder = if (type == PCM) AudioRecorder(type) else MediaRecord(type)
private var audioFile: File? = null
private var cancelRecord: AtomicBoolean = AtomicBoolean(false)
private val audioManager: AudioManager = context.applicationContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
fun start(maxDuration: Int = 120) {
this.maxDuration = maxDuration * 1000
startRecord()
}
fun stop(cancel: Boolean = false) {
stopRecord(cancel)
}
fun release() {
recorder.release()
}
fun isRecording() = recorder.isRecording()
private fun startRecord() {
audioManager.requestAudioFocus(null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
if (recorder.isRecording()) {
setState(STATE_FAILED)
return
}
if (getFreeSpace() <= 0) {
setState(STATE_FAILED)
return
}
audioFile = getAudioFile()
if (audioFile == null) setState(STATE_FAILED)
cancelRecord.set(false)
try {
if (! cancelRecord.get()) {
setState(STATE_READY)
if (hasPermission()) {
launch { recorder.start(audioFile !!, maxDuration) }
setState(STATE_START)
} else {
stopRecord(false)
}
}
} catch (e: Exception) {
e.printStackTrace()
stopRecord(false)
}
}
private fun hasPermission(): Boolean {
return context.checkCallingOrSelfPermission(android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
&& context.checkCallingOrSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
}
private fun stopRecord(cancel: Boolean) {
if (! recorder.isRecording()) {
return
}
cancelRecord.set(cancel)
audioManager.abandonAudioFocus(null)
try {
recorder.stop()
} catch (e: Exception) {
e.printStackTrace()
} finally {
handleRecordEnd(isSuccess = true, isReachMaxTime = false)
}
}
private fun handleRecordEnd(isSuccess: Boolean, isReachMaxTime: Boolean) {
if (cancelRecord.get()) {
audioFile?.deleteOnExit()
setState(STATE_CANCELED)
} else if (! isSuccess) {
audioFile?.deleteOnExit()
setState(STATE_FAILED)
} else {
if (isAudioFileInvalid()) {
setState(STATE_FAILED)
if (isReachMaxTime) {
setState(STATE_REACH_MAX_TIME)
}
} else {
setState(STATE_SUCCESS)
}
}
}
private fun isAudioFileInvalid() = audioFile == null || ! audioFile !!.exists() || audioFile !!.length() <= 0
/**
* change recording state and invoke according callback to main thread
*/
private fun setState(state: Int) {
callbackHandler.post {
when (state) {
STATE_FAILED -> onRecordFail?.invoke()
STATE_READY -> onRecordReady?.invoke()
STATE_START -> audioFile?.let { onRecordStart?.invoke(it) }
STATE_CANCELED -> onRecordCancel?.invoke()
STATE_SUCCESS -> audioFile?.let { onRecordSuccess?.invoke(it, recorder.getDuration()) }
STATE_REACH_MAX_TIME -> onRecordReachedMaxTime?.invoke(maxDuration)
}
}
}
private fun getFreeSpace(): Long {
if (Environment.MEDIA_MOUNTED != Environment.getExternalStorageState()) {
return 0L
}
return try {
val stat = StatFs(context.getExternalFilesDir(Environment.DIRECTORY_MUSIC)?.absolutePath)
stat.run { blockSizeLong * availableBlocksLong }
} catch (e: Exception) {
0L
}
}
private fun getAudioFile(): File? {
val audioFilePath = context.getExternalFilesDir(Environment.DIRECTORY_MUSIC)?.absolutePath
if (audioFilePath.isNullOrEmpty()) return null
return File("$audioFilePath${File.separator}${UUID.randomUUID()}.$type")
}
/**
* the implementation of [Recorder] define the detail of how to record audio.
* [AudioManager] works with [Recorder] and dont care about the recording details
*/
interface Recorder {
/**
* audio output format
*/
var outputFormat: String
/**
* whether audio is recording
*/
fun isRecording(): Boolean
/**
* the length of audio
*/
fun getDuration(): Long
/**
* start audio recording, it is time-consuming
*/
fun start(outputFile: File, maxDuration: Int)
/**
* stop audio recording
*/
fun stop()
/**
* release the resource of audio recording
*/
fun release()
}
/**
* record audio by [android.media.MediaRecorder]
*/
inner class MediaRecord(override var outputFormat: String) : Recorder {
private var starTime = AtomicLong()
private val listener = MediaRecorder.OnInfoListener { _, what, _ ->
when (what) {
MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED -> {
stop()
handleRecordEnd(isSuccess = true, isReachMaxTime = true)
}
else -> {
handleRecordEnd(isSuccess = false, isReachMaxTime = false)
}
}
}
private val errorListener = MediaRecorder.OnErrorListener { _, _, _ ->
handleRecordEnd(isSuccess = false, isReachMaxTime = false)
}
private val recorder = MediaRecorder()
private var isRecording = AtomicBoolean(false)
private var duration = 0L
override fun isRecording(): Boolean = isRecording.get()
override fun getDuration(): Long = duration
override fun start(outputFile: File, maxDuration: Int) {
val format = when (outputFormat) {
AMR -> MediaRecorder.OutputFormat.AMR_NB
else -> MediaRecorder.OutputFormat.AAC_ADTS
}
val encoder = when (outputFormat) {
AMR -> MediaRecorder.AudioEncoder.AMR_NB
else -> MediaRecorder.AudioEncoder.AAC
}
starTime.set(SystemClock.elapsedRealtime())
isRecording.set(true)
recorder.apply {
reset()
setAudioSource(MediaRecorder.AudioSource.MIC)
setOutputFormat(format)
setOutputFile(outputFile.absolutePath)
setAudioEncoder(encoder)
if (outputFormat == AAC) {
setAudioSamplingRate(22050)
setAudioEncodingBitRate(32000)
}
setOnInfoListener(listener)
setOnErrorListener(errorListener)
setMaxDuration(maxDuration)
prepare()
start()
}
}
override fun stop() {
recorder.stop()
isRecording.set(false)
duration = SystemClock.elapsedRealtime() - starTime.get()
}
override fun release() {
recorder.release()
}
}
/**
* record audio by [android.media.AudioRecord]
*/
inner class AudioRecorder(override var outputFormat: String) : Recorder {
private var bufferSize: Int = 0
private var isRecording = AtomicBoolean(false)
private var startTime = AtomicLong()
private var duration = 0L
private val audioRecord by lazy {
bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT)
AudioRecord(SOURCE, SAMPLE_RATE, CHANNEL_IN_MONO, ENCODING_PCM_16BIT, bufferSize)
}
override fun isRecording(): Boolean = isRecording.get()
override fun getDuration(): Long = duration
override fun start(outputFile: File, maxDuration: Int) {
if (audioRecord.state == AudioRecord.STATE_UNINITIALIZED) return
isRecording.set(true)
startTime.set(SystemClock.elapsedRealtime())
outputFile.outputStream().use { outputStream ->
audioRecord.startRecording()
val audioData = ByteArray(bufferSize)
while (continueRecord(maxDuration)) {
audioRecord.read(audioData, 0, audioData.size)
outputStream.write(audioData)
}
if (audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING) {
audioRecord.stop()
}
if (duration >= maxDuration) handleRecordEnd(isSuccess = true, isReachMaxTime = true)
}
}
private fun continueRecord(maxDuration: Int): Boolean {
duration = SystemClock.elapsedRealtime() - startTime.get()
return isRecording.get() && audioRecord.recordingState == AudioRecord.RECORDSTATE_RECORDING && duration < maxDuration
}
override fun stop() {
isRecording.set(false)
}
override fun release() {
audioRecord.release()
}
}
}
复制代码下一篇会接着这个主题，继续分析如何利用 MediaCodec 将 PCM 文件进行硬编码转换成 AAC 文件。
talk is cheap, show me the code
完整代码在这个repo中的AudioManager类中
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
![[02/27][官改] Simplicity@MIX2 ROM更新-一一网](https://www.proyy.com/wp-content/uploads/2020/02/3168457341.jpg)
![[桜井宁宁]COS和泉纱雾超可爱写真福利集-一一网](https://www.proyy.com/skycj/data/images/2020-12-13/4d3cf227a85d7e79f5d6b4efb6bde3e8.jpg)
![[桜井宁宁] 爆乳奶牛少女cos写真-一一网](https://www.proyy.com/skycj/data/images/2020-12-13/d40483e126fcf567894e89c65eaca655.jpg)
