音频学习笔记之音频采集

Android 提供的音频开发相关的API ：
(1)音频采集： MediaRecoder , AudioRecord
(2)音频播放： SoundPool ,MediaPlayer ,AudioTrack
(3)音频编解码： MediaCodec

Andorid SDK 提供了两套音频采集的API ，分别是MediaRecoder 和 AudioRecord ，前者更接近上层，后者更接近底层，更接近底层的更加灵活地控制，可以得到原始的一帧帧的PCM音频数据

(一) AudioRecoed 的工作流程
（1）配置参数，初始化内部的音频缓冲区
（2）开始采集
（3）需要一个线程，不断地从AudioRecord的缓冲区将音频数据“读”出来，注意：这一过程一定要及时，否则会出现overrun的错误，意味应用层没有及时地“取走”音频数据，导致内部的音频缓冲区溢出
（4）停止采集，释放资源

public AudioRecord(int audioSource, int sampleRateInHz, int channelConfig, int audioFormat,
int bufferSizeInBytes)
参数说明：
1> audioSorce 参数是指音频采集的输入源，可选用的常量的形式定义在MediaRecorder.AudioSource 类中，DEFULT（默认），VOICE_RECOGNITION(用于手机麦克风输入)，VOICE_COMMUNICATION（用于VoLP应用）
2> sampleRateInHz 采样率
注意：目前44100HZ是为一保证兼容所有手机的采样率
3> channelConfig 通道数的配置，可选的值以常量的形式定义在AudioFormat 类中
常用的是CHANNEL_IN_MONO:单通道 ，CHANNEL_IN_STEREO:双通道
4>audioFormat:这个参数是用来配置“数据位宽”的，可以选的值也是以常量的形式定义在AudioFormat类中，常用的16bit ，和8bit
注意：前者是可以保证兼容的所有Android手机
5>bufferSizeInBytes :它配置的是AudioRecord内部的音频缓冲区的大小，该缓冲区的大小不能低于一帧“音频”的大小
计算公式：int size = 采样率 * 位宽 * 采样时间 * 通道数
采样时间一般为2.5～120ms ,在android 中AudioRecord 类 提供了一个帮忙确定缓冲区的类int geMinBUfferSize(int sampleRateInHz,int channelConfig,int audioFormat) //采样率，声道数，数据位宽

package com.example.audiodemo;

import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.util.Log;

/**
 * 音频采集
 */
public class AudioCapturer {
    private static final String TAG = "AudioCapturer";
    private static final int DEFAULT_SOURCE = MediaRecorder.AudioSource.MIC;
    private static final int DEFAULT_SAMPLE_RATE = 44100;
    private static final int DEFAULT_CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO;
    private static final int DEFAULT_AUDIO_FORMAT = AudioFormat.ENCODING_PCM_16BIT;

    private AudioRecord mAudioRecord;
    private int mMinBufferSize = 0;

    private Thread mCaptureThread;
    private boolean mIsCaptureStarted = false;
    private volatile boolean mIsLoopExit = false;

    private OnAudioFrameCapturedListener mAudioFrameCapturedListener;

    public interface OnAudioFrameCapturedListener {
        public void onAudioFrameCaptured(byte[] audioData);
    }

    public void setAudioFrameCapturedListener(OnAudioFrameCapturedListener listener){
        mAudioFrameCapturedListener = listener;
    }

    public boolean startCapturer(){
        return startCapturer(DEFAULT_SOURCE,DEFAULT_SAMPLE_RATE,DEFAULT_CHANNEL_CONFIG,DEFAULT_AUDIO_FORMAT);
    }

    private boolean startCapturer(int source,int sampleRate,int channelConfig,int audioFormat){

        if (mIsCaptureStarted){
            Log.d(TAG, "音频采集已经开始");
            return false;
        }

        mMinBufferSize = AudioRecord.getMinBufferSize(sampleRate,channelConfig,audioFormat);
        if (mMinBufferSize == AudioRecord.ERROR_BAD_VALUE){
            Log.d(TAG, "无效参数");
            return false;
        }

        Log.d(TAG, "音频最小缓冲区为：" + mMinBufferSize + "bytes");
        mAudioRecord = new AudioRecord(source, sampleRate, channelConfig, audioFormat, mMinBufferSize);
        if (mAudioRecord.getState() == AudioRecord.STATE_UNINITIALIZED){
            Log.d(TAG, "初始化失败");
            return false;
        }

        mAudioRecord.startRecording();
        mIsLoopExit = false;

        mCaptureThread = new Thread(new CapturerRunnable());
        mCaptureThread.start();

        mIsCaptureStarted = true;

        return true;

    }

    public void stopCapturer(){
        if (!mIsCaptureStarted){
            return;
        }

        mIsLoopExit = true;
        try {
            /** 是给线程设置中断标志;  其作用是中断此线程 */
            mCaptureThread.interrupt();
            /** “等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。*/
            mCaptureThread.join(1000);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (mAudioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) {
            mAudioRecord.stop();
        }

        mAudioRecord.release();

        mIsCaptureStarted = false;
        mAudioFrameCapturedListener = null;
    }

    private class CapturerRunnable implements Runnable{
        @Override
        public void run() {
            while (!mIsLoopExit){
                byte[] bytes = new byte[mMinBufferSize];
                /** audioData ：写入的音频录制数据
                 *  offsetInBytes： audioData的起始偏移值，单位byte
                 *  sizeInBytes： 读取的最大字节数
                 *  读入缓冲区的总byte数，如果对象属性没有初始化，则返回ERROR_INVALID_OPERATION，
                 *  如果参数不能解析成有效的数据或索引，则返回ERROR_BAD_VALUE。
                 *  读取的总byte数不会超过sizeInBytes
                 */
                int ret = mAudioRecord.read(bytes,0,mMinBufferSize);
                if (ret == AudioRecord.ERROR_INVALID_OPERATION) {
                    Log.e(TAG , "Error ERROR_INVALID_OPERATION");
                } else if (ret == AudioRecord.ERROR_BAD_VALUE) {
                    Log.e(TAG , "Error ERROR_BAD_VALUE");
                }else {
                    if (mAudioFrameCapturedListener != null){
                        mAudioFrameCapturedListener.onAudioFrameCaptured(bytes);
                    }
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

参考文献：https://blog.51cto.com/ticktick/category15.html

注意要申请权限：

  /**
     * 动态申请录音权限
     */
    private void requestPermission(){
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO)
                != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.RECORD_AUDIO}, 1001);
        }
    }
1
2
3
4
5
6
7
8
9
10