音频数据采集-AudioRecord
一. AudioRecord 和 MediaRecorder
Android 提供了两个 API 用于录音，AudioRecord 和 MediaRecorder
- AudioRecord:能够获取原始的 PCM 数据，实现音频数据的实时处理，PCM 音频不能直接播放，需要通过 AudioTrack 播放。
- MediaRecorder:封装了编码器，内部集成了录音，编码等功能，但是支持的格式较少，且不能实时处理音频数据。
因此在需要处理音频数据的基础上，通常选择用 AudioRecord 来采集音频数据。
二. AudioRecord 的使用
1. 构造
构造 AudioRecord 需要几个参数：
- int audioSource 音频源，通常使用麦克风
MediaRecorder.AudioSource.MIC
- int sampleRateInHz 采样率，一秒钟对数据的采样次数，采样率越高，音质越好
16_000 或者 44_100 等
- int channelConfig 音频通道，单声道或者双声道
AudioFormat.CHANNEL_IN_MONO
AudioFormat.CHANNEL_IN_STEREO
- int audioFormat 音频格式
AudioFormat.ENCODING_PCM_16BIT
AudioFormat.ENCODING_PCM_8BIT
- int bufferSizeInBytes 音频数据写入缓冲区的总数,可以通过AudioRecord.getMinBufferSize获取最小的缓冲区,将音频采集到缓冲区中然后再从缓冲区中读取
2. 开始录音
mAudioRecord.startRecording();
3. 读取数据
mAudioRecord.read(@NonNull byte[] audioData, int offsetInBytes, int sizeInBytes);
>>audioData 写入的数组
>>offsetInBytes 偏移
>>sizeInBytes 读取的数据量
mAudioRecord.read(@NonNull short[] audioData, int offsetInShorts, int sizeInShorts);
4. 停止录音
mAudioRecord.stop();
5. 释放资源
mAudioRecord.release();
三. 封装的 DAudioRecord
package com.example.dplayer.audio;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.util.Log;
import androidx.annotation.IntDef;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class DAudioRecord implements IAudioRecord {
private static final String TAG = "DAudioRecord";
public final static int DEFAULT_INPUT = MediaRecorder.AudioSource.MIC;
public final static int DEFAULT_SAMPLE_RATE_IN_HZ = 16_000;
public final static int DEFAULT_CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO;
public final static int DEFAULT_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
public final static int DEFAULT_BUFFER_SIZE_IN_BYTES = 2048;
@IntDef({Status.NO_READY, Status.READY, Status.RECORDING, Status.PAUSE, Status.STOP, Status.DESTROY})
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD, ElementType.LOCAL_VARIABLE})
public @interface Status {
int NO_READY = 0;
int READY = 1;
int RECORDING = 2;
int PAUSE = 3;
int STOP = 4;
int DESTROY = 5;
}
private final static int MSG_START = 1;
private final static int MSG_RESUME = 2;
private final static int MSG_PAUSE = 3;
private final static int MSG_STOP = 4;
private final static int MSG_DESTROY = 5;
@Status
private int mStatus;
private int mAudioSource;
private int mSampleRateInHz;
private int mChannelConfig;
private int mAudioFormat;
private int mBufferSizeInBytes;
private byte[] mBuffer;
private AudioRecord mAudioRecord;
private RecordCallback mRecordCallback;
private Handler mHandler;
private HandlerThread mHandlerThread;
private boolean mStopReading = false;
public interface RecordCallback {
void onSuccess(byte[] data);
void onError(int code, Exception e);
}
public interface OnStateListener {
void onStart();
void onPause();
void onResume();
void onStop();
}
private OnStateListener mOnStateListener;
public void setOnStateListener(OnStateListener onStateListener) {
mOnStateListener = onStateListener;
}
public void setRecordCallback(RecordCallback recordCallback) {
mRecordCallback = recordCallback;
}
protected DAudioRecord(
int audioSource,
int sampleRateInHz,
int channelConfig,
int audioFormat,
int bufferSizeInBytes,
byte[] buffer) {
mAudioSource = audioSource;
mSampleRateInHz = sampleRateInHz;
mChannelConfig = channelConfig;
mAudioFormat = audioFormat;
mBufferSizeInBytes = bufferSizeInBytes;
mBuffer = buffer;
mStatus = Status.NO_READY;
mBufferSizeInBytes = Math.max(mBufferSizeInBytes, AudioRecord.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat));
createAudioRecord();
createThread();
}
private void createAudioRecord() {
if (mStatus != Status.NO_READY) {
Log.e(TAG, "status is not no ready!");
return;
}
mAudioRecord = new AudioRecord(
mAudioSource,
mSampleRateInHz,
mChannelConfig,
mAudioFormat,
mBufferSizeInBytes);
mStatus = Status.READY;
Log.i(TAG, "createAudioRecord, audio record ready");
}
private void createThread() {
mHandlerThread = new HandlerThread("audio-thread");
mHandlerThread.start();
mHandler = new Handler(mHandlerThread.getLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case MSG_START:
onStart();
break;
case MSG_RESUME:
onResume();
break;
case MSG_PAUSE:
onPause();
break;
case MSG_STOP:
onStop();
break;
case MSG_DESTROY:
onDestroy();
break;
}
return true;
}
});
}
@Override
public void start() {
mStopReading = false;
mHandler.sendEmptyMessage(MSG_START);
}
private void onStart() {
if (mStatus != Status.STOP && mStatus != Status.READY) {
return;
}
mStatus = Status.RECORDING;
while (mAudioRecord.getState() == AudioRecord.STATE_UNINITIALIZED) {
Log.w(TAG,"STATE_UNINITIALIZED");
}
mAudioRecord.startRecording();
Log.i(TAG, "start");
if (mOnStateListener != null) {
mOnStateListener.onStart();
}
doRecording();
}
@Override
public void resume() {
mStopReading = false;
mHandler.sendEmptyMessage(MSG_RESUME);
}
private void onResume() {
if (mStatus != Status.PAUSE) {
return;
}
mStatus = Status.RECORDING;
mAudioRecord.startRecording();
Log.d(TAG, "resume");
doRecording();
}
@Override
public void pause() {
mStopReading = true;
mHandler.sendEmptyMessage(MSG_PAUSE);
}
private void onPause() {
if (mStatus != Status.RECORDING) {
return;
}
mStatus = Status.PAUSE;
mAudioRecord.stop();
Log.d(TAG, "pause");
}
@Override
public void stop() {
mStopReading = true;
mHandler.sendEmptyMessage(MSG_STOP);
}
private void onStop() {
if (mStatus != Status.RECORDING && mStatus != Status.PAUSE) {
return;
}
mStatus = Status.STOP;
mAudioRecord.stop();
Log.i(TAG, "stop");
}
@Override
public void destroy() {
mStopReading = true;
mHandler.sendEmptyMessage(MSG_DESTROY);
}
private void onDestroy() {
if (mAudioRecord != null) {
mAudioRecord.release();
mAudioRecord = null;
}
mStatus = Status.DESTROY;
Log.i(TAG, "destroy");
}
private void doRecording() {
try {
onReading();
} catch (Exception e) {
handleError(AudioRecord.ERROR, e);
}
}
private void onReading() {
int ret;
while (mAudioRecord != null && !mStopReading && mAudioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING
&& mStatus == Status.RECORDING) {
ret = mAudioRecord.read(mBuffer, 0, mBufferSizeInBytes);
if (ret >= 0) {
handleSuccess(mBuffer);
continue;
}
handleErrorRead(ret);
}
Log.i(TAG,"stop reading");
}
private void handleErrorRead(int ret) {
switch (ret) {
case AudioRecord.ERROR_INVALID_OPERATION:
handleError(ret, new Exception("the object isn't properly initialized"));
break;
case AudioRecord.ERROR_BAD_VALUE:
handleError(ret, new Exception("the parameters don't resolve to valid data and indexes"));
break;
case AudioRecord.ERROR_DEAD_OBJECT:
handleError(ret, new Exception("the object is not valid anymore and" +
"needs to be recreated. The dead object error code is not returned if some data was" +
"successfully transferred. In this case, the error is returned at the next read"));
break;
case AudioRecord.ERROR:
handleError(ret, new Exception("unknown error"));
break;
}
}
private void handleSuccess(byte[] buffer) {
if (mRecordCallback != null) {
mRecordCallback.onSuccess(buffer);
}
}
private void handleError(int code, Exception e) {
if (mRecordCallback != null) {
mRecordCallback.onError(code, e);
}
}
public static final class Builder {
private int mAudioSource;
private int mSampleRateInHz;
private int mChannelConfig;
private int mAudioFormat;
private int mBufferSizeInBytes;
private byte[] mBuffer;
public Builder() {
this(DEFAULT_INPUT,
DEFAULT_SAMPLE_RATE_IN_HZ,
DEFAULT_CHANNEL_CONFIG,
DEFAULT_ENCODING,
DEFAULT_BUFFER_SIZE_IN_BYTES,
new byte[DEFAULT_BUFFER_SIZE_IN_BYTES]);
}
public Builder(
int audioSource,
int sampleRateInHz,
int channelConfig,
int audioFormat,
int bufferSizeInBytes,
byte[] buffer) {
mAudioSource = audioSource;
mSampleRateInHz = sampleRateInHz;
mChannelConfig = channelConfig;
mAudioFormat = audioFormat;
mBufferSizeInBytes = bufferSizeInBytes;
mBuffer = buffer;
}
public Builder setAudioSource(int audioSource) {
mAudioSource = audioSource;
return this;
}
public Builder setSampleRateInHz(int sampleRateInHz) {
mSampleRateInHz = sampleRateInHz;
return this;
}
public Builder setChannelConfig(int channelConfig) {
mChannelConfig = channelConfig;
return this;
}
public Builder setAudioFormat(int audioFormat) {
mAudioFormat = audioFormat;
return this;
}
public Builder setBufferSizeInBytes(int bufferSizeInBytes) {
mBufferSizeInBytes = bufferSizeInBytes;
return this;
}
public DAudioRecord build() {
return new DAudioRecord(
mAudioSource,
mSampleRateInHz,
mChannelConfig,
mAudioFormat,
mBufferSizeInBytes,
mBuffer);
}
}
}
github Demo
