音频采集（AudioRecorder）

音频采集

想更好地了解音频采集，首先要去了解一些音频入门基础知识。关于一些音频开发的一些基础知识，这里就不一一讲解了，可以去了解Android音频技术开发的一些基础知识

Android音频采集（捕获）

android平台上的音频采集一般就两种方式：

使用MediaRecorder进行音频采集。

MediaRecorder 是基于 AudioRecorder 的 API(最终还是会创建AudioRecord用来与AudioFlinger进行交互) ，它可以直接将采集到的音频数据转化为执行的编码格式，并保存。这种方案相较于调用系统内置的用用程序，便于开发者在UI界面上布局，而且系统封装的很好，便于使用，唯一的缺点是使用它录下来的音频是经过编码的，没有办法的得到原始的音频。同时MediaRecorder即可用于音频的捕获也可以用于视频的捕获相当的强大。实际开发中没有特殊需求的话，用的是比较多的！

使用AudioRecord进行音频采集。

AudioRecord 是一个比较偏底层的API,它可以获取到一帧帧PCM数据，之后可以对这些数据进行处理。AudioRecord这种方式采集最为灵活，使开发者最大限度的处理采集的音频,同时它捕获到的音频是原始音频PCM格式的！像做变声处理的需要就必须要用它收集音频。

在实际开发中，它也是最常用来采集音频的手段。如直播技术采用的就是AudioRecorder采集音频数据。AudioRecorder采集也是本文介绍的重点。

AudioRecord的基本参数

audioResource:音频采集的来源
audioSampleRate:音频采样率
channelConfig:声道
audioFormat:音频采样精度，指定采样的数据的格式和每次采样的大小。
bufferSizeInBytes：AudioRecord 采集到的音频数据所存放的缓冲区大小。
获取最小的缓冲区大小，用于存放AudioRecord采集到的音频数据。

//指定音频源 这个和MediaRecorder是相同的 MediaRecorder.AudioSource.MIC指的是麦克风
        private static final int mAudioSource = MediaRecorder.AudioSource.MIC;
        //指定采样率 （MediaRecoder 的采样率通常是8000Hz AAC的通常是44100Hz。 设置采样率为44100，目前为常用的采样率，官方文档表示这个值可以兼容所有的设置）
        private static final int mSampleRateInHz=44100 ;
        //指定捕获音频的声道数目。在AudioFormat类中指定用于此的常量
        private static final int mChannelConfig= AudioFormat.CHANNEL_CONFIGURATION_MONO; //单声道
        //指定音频量化位数 ,在AudioFormaat类中指定了以下各种可能的常量。通常我们选择ENCODING_PCM_16BIT和ENCODING_PCM_8BIT PCM代表的是脉冲编码调制，它实际上是原始音频样本。
        //因此可以设置每个样本的分辨率为16位或者8位，16位将占用更多的空间和处理能力,表示的音频也更加接近真实。
        private static final int mAudioFormat=AudioFormat.ENCODING_PCM_16BIT;
        //指定缓冲区大小。调用AudioRecord类的getMinBufferSize方法可以获得。
        private int mBufferSizeInBytes= AudioRecord.getMinBufferSize(mSampleRateInHz,mChannelConfig, mAudioFormat);//计算最小缓冲区
        //创建AudioRecord。AudioRecord类实际上不会保存捕获的音频，因此需要手动创建文件并保存下载。 
        private AudioRecord mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,mSampleRateInHz,mChannelConfig,
                mAudioFormat, mBufferSizeInBytes);//创建AudioRecorder对象

以上的基本参数对于基本的音频采集已经够用了，但参数还有很多就不一一说明了，对于参数值的设置也要看项目设计而设置。我们了解了基本参数，那就来看看AudioRecord的一些状态。

AudioRecord的状态用意

AudioRecord的状态对于我们做业务逻辑时会起到很好的作用。下面说来说说一些常用的状态。

获取AudioRecord的状态

用于检测AudioRecord是否确保了获得适当的硬件资源。在AudioRecord对象实例化之后调用getState()。

STATE_INITIALIZED 初始完毕

STATE_UNINITIALIZED 未初始化

开始采集时调用mAudioRecord.startRecording()开始录音。

开始采集之后，状态自动变为RECORDSTATE_RECORDING。

停止采集时调用mAudioRecord.stop()停止录音。

停止采集之后，状态自动变为 RECORDSTATE_STOPPED 。

读取录制内容，将采集到的数据读取到缓冲区，方法调用的返回值的状态码。

情况异常：

ERROR_INVALID_OPERATION if the object wasn't properly initialized。

ERROR_BAD_VALUE if the parameters don't resolve to valid data and indexes。

情况正常：the number of bytes that were read。

AudioRecord音频采集的基本流程

构造一个 AudioRecord 对象。
开始采集。
读取采集的数据。
停止采集。

构造一个 AudioRecord 对象

mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,mSampleRateInHz,mChannelConfig,
mAudioFormat, mBufferSizeInBytes);//创建AudioRecorder对象

获取 getMinBufferSize 值

mBufferSizeInBytes 是 AudioRecord 采集到的音频数据所存放的缓冲区大小。

mBufferSizeInBytes = AudioRecord.getMinBufferSize(audioSampleRate, channelConfig, audioFormat);

特别注意：这个大小不能随便设置，AudioRecord 提供对应的 API 来获取这个值。

通过 mBufferSizeInBytes 返回就可以知道传入给AudioRecord.getMinBufferSize的参数是否支持当前的硬件设备。

if (AudioRecord.ERROR_BAD_VALUE == mBufferSizeInBytes || AudioRecord.ERROR == mBufferSizeInBytes) {
            throw new RuntimeException("Unable to getMinBufferSize");
        }
    
    //bufferSizeInBytes is available...

    //或者检测AudioRecord是否确保了获得适当的硬件资源。
    if (mAudioRecord.getState() == AudioRecord.STATE_UNINITIALIZED) {
        throw new RuntimeException("The AudioRecord is not uninitialized");
    }

开始采集

我们在开始录音之前，首先要判断一下AudioRecord的状态是否已经初始化完毕了，然后再去调用audioRecord.startRecording()。


    //判断AudioRecord的状态是否初始化完毕
    //在AudioRecord对象构造完毕之后，就处于AudioRecord.STATE_INITIALIZED状态了。
    if (mAudioRecord.getState() == AudioRecord.STATE_UNINITIALIZED) {
         throw new RuntimeException("The AudioRecord is not uninitialized");
    }

读取采集的数据

由于AudioRecord 在采集数据时会将数据存放到缓冲区中，因此我们只需要创建一个数据流去从缓冲区中将采集的数据读取出来即可。

创建一个数据流，一边从 AudioRecord 中读取音频数据到缓冲区，一边将缓冲区中数据写入到数据流。
因为需要使用IO操作，因此读取数据的过程应该在子线程中执行。

@Override
    public void run() {

        //标记为开始采集状态
        isRecording = true;
        //创建一个流，存放从AudioRecord读取的数据
        mRecordingFile = new File(mFileRoot,mFileName);
        if(mRecordingFile.exists()){//音频文件保存过了删除
            mRecordingFile.delete();
        }
        try {
            mRecordingFile.createNewFile();//创建新文件
        } catch (IOException e) {
            e.printStackTrace();
            Log.e("lu","创建储存音频文件出错");
        }

        try {
            //获取到文件的数据流
            mDataOutputStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(mRecordingFile)));
            byte[] buffer = new byte[mBufferSizeInBytes];
            mAudioRecord.startRecording();//开始录音
            //getRecordingState获取当前AudioReroding是否正在采集数据的状态
            while (isRecording && mAudioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) {
                int bufferReadResult = mAudioRecord.read(buffer,0,mBufferSizeInBytes);
                for (int i = 0; i < bufferReadResult; i++)
                {
                    mDataOutputStream.write(buffer[i]);
                }
            }
            mDataOutputStream.close();
        } catch (Throwable t) {
            Log.e("lu", "Recording Failed");
            stopRecord();
        }
    }

停止采集

//停止录音
    public void stopRecord() {
        isRecording = false;
        //停止录音，回收AudioRecord对象，释放内存
        if (mAudioRecord != null) {
            if (mAudioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) {
                mAudioRecord.stop();
            }
            if (mAudioRecord.getState() == AudioRecord.STATE_INITIALIZED) {
                mAudioRecord.release();
            }
        }
    }

注意添加权限

有时候代码写完了就行动了，很容易忽略在AndroidManifest.xml中添加权限。

总结

直播技术采用的就是AudioRecorder采集音频数据。
mBufferSizeInBytes这个大小不能随便设置，AudioRecord 提供对应的 API 来获取这个值。
一些AudioRecord状态判断是否支持当前的硬件设备。
注意AndroidManifest.xml中添加权限。
AudioRecord保存的音频文件为.pcm格式，不能直接播放。它是一个原始的文件，没有任何播放格式，因此就无法被播放器识别并播放。

播放PCM文件的方案

使用 AudioTrack 播放PCM格式的音频数据。
将PCM数据转化为wav格式的数据，这样就可以被播放器识别。

贴出AudioRecord源代码，写得不好的，请大家多多指正。

import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class AudioRecordActivity extends AppCompatActivity implements Runnable {

   private Button mBtnStartRecord,mBtnStopRecord;
   //指定音频源 这个和MediaRecorder是相同的 MediaRecorder.AudioSource.MIC指的是麦克风
   private static final int mAudioSource = MediaRecorder.AudioSource.MIC;
   //指定采样率 （MediaRecoder 的采样率通常是8000Hz AAC的通常是44100Hz。 设置采样率为44100，目前为常用的采样率，官方文档表示这个值可以兼容所有的设置）
   private static final int mSampleRateInHz=44100 ;
   //指定捕获音频的声道数目。在AudioFormat类中指定用于此的常量
   private static final int mChannelConfig= AudioFormat.CHANNEL_CONFIGURATION_MONO; //单声道
   //指定音频量化位数 ,在AudioFormaat类中指定了以下各种可能的常量。通常我们选择ENCODING_PCM_16BIT和ENCODING_PCM_8BIT PCM代表的是脉冲编码调制，它实际上是原始音频样本。
   //因此可以设置每个样本的分辨率为16位或者8位，16位将占用更多的空间和处理能力,表示的音频也更加接近真实。
   private static final int mAudioFormat=AudioFormat.ENCODING_PCM_16BIT;
   //指定缓冲区大小。调用AudioRecord类的getMinBufferSize方法可以获得。
   private int mBufferSizeInBytes;

   private File mRecordingFile;//储存AudioRecord录下来的文件
   private boolean isRecording = false; //true表示正在录音
   private AudioRecord mAudioRecord=null;
   private File mFileRoot=null;//文件目录
   //存放的目录路径名称
   private static final String mPathName = Environment.getExternalStorageDirectory().getAbsolutePath()+ "/AudiioRecordFile";
   //保存的音频文件名
   private static final String mFileName = "audiorecordtest.pcm";
   //缓冲区中数据写入到数据，因为需要使用IO操作，因此读取数据的过程应该在子线程中执行。
   private Thread mThread;
   private DataOutputStream mDataOutputStream;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_audio_record);

       initDatas();
       initUI();

   }

   //初始化数据
   private void initDatas() {
       mBufferSizeInBytes = AudioRecord.getMinBufferSize(mSampleRateInHz,mChannelConfig, mAudioFormat);//计算最小缓冲区
       mAudioRecord = new AudioRecord(mAudioSource,mSampleRateInHz,mChannelConfig,
               mAudioFormat, mBufferSizeInBytes);//创建AudioRecorder对象

       mFileRoot = new File(mPathName);
       if(!mFileRoot.exists())
           mFileRoot.mkdirs();//创建文件夹

   }

   //初始化UI
   private void initUI() {
       mBtnStartRecord = findViewById(R.id.btn_start_record);
       mBtnStopRecord = findViewById(R.id.btn_stop_record);
       mBtnStartRecord.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               startRecord();
           }
       });

       mBtnStopRecord.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               stopRecord();
           }
       });
   }

 //开始录音
    public void startRecord() {

        //AudioRecord.getMinBufferSize的参数是否支持当前的硬件设备
        if (AudioRecord.ERROR_BAD_VALUE == mBufferSizeInBytes || AudioRecord.ERROR == mBufferSizeInBytes) {
            throw new RuntimeException("Unable to getMinBufferSize");
        }else{
            destroyThread();
            isRecording = true;
            if(mThread == null){
                mThread = new Thread(this);
                mThread.start();//开启线程
            }
        }
    }

    /**
     * 销毁线程方法
     */
    private void destroyThread() {
        try {
            isRecording = false;
            if (null != mThread && Thread.State.RUNNABLE == mThread.getState()) {
                try {
                    Thread.sleep(500);
                    mThread.interrupt();
                } catch (Exception e) {
                    mThread = null;
                }
            }
            mThread = null;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            mThread = null;
        }
    }

    //停止录音
    public void stopRecord() {
        isRecording = false;
        //停止录音，回收AudioRecord对象，释放内存
        if (mAudioRecord != null) {
            if (mAudioRecord.getState() == AudioRecord.STATE_INITIALIZED) {//初始化成功
                mAudioRecord.stop();
            }
            if (mAudioRecord  !=null ) {
                mAudioRecord.release();
            }
        }
    }

    @Override
    public void run() {

        //标记为开始采集状态
        isRecording = true;
        //创建一个流，存放从AudioRecord读取的数据
        mRecordingFile = new File(mFileRoot,mFileName);
        if(mRecordingFile.exists()){//音频文件保存过了删除
            mRecordingFile.delete();
        }
        try {
            mRecordingFile.createNewFile();//创建新文件
        } catch (IOException e) {
            e.printStackTrace();
            Log.e("lu","创建储存音频文件出错");
        }

        try {
            //获取到文件的数据流
            mDataOutputStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(mRecordingFile)));
            byte[] buffer = new byte[mBufferSizeInBytes];


            //判断AudioRecord未初始化，停止录音的时候释放了，状态就为STATE_UNINITIALIZED
            if(mAudioRecord.getState() == mAudioRecord.STATE_UNINITIALIZED){
                initDatas();
            }

            mAudioRecord.startRecording();//开始录音
            //getRecordingState获取当前AudioReroding是否正在采集数据的状态
            while (isRecording && mAudioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) {
                int bufferReadResult = mAudioRecord.read(buffer,0,mBufferSizeInBytes);
                for (int i = 0; i < bufferReadResult; i++)
                {
                    mDataOutputStream.write(buffer[i]);
                }
            }
            mDataOutputStream.close();
        } catch (Throwable t) {
            Log.e("lu", "Recording Failed");
            stopRecord();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        destroyThread();
        stopRecord();

    }
}