版权声明 转载请说明出处：http://www.cnblogs.com/renhui/p/7457321.html

一、AudioRecord API详解

AudioRecord是Android系统提供的用于实现录音的功能类。
要想了解这个类的具体的说明和用法，我们可以去看一下官方的文档：

　　AndioRecord类的主要功能是让各种JAVA应用能够管理音频资源，以便它们通过此类能够录制声音相关的硬件所收集的声音。此功能的实现就是通过”pulling”（读取）AudioRecord对象的声音数据来完成的。在录音过程中，应用所需要做的就是通过后面三个类方法中的一个去及时地获取AudioRecord对象的录音数据. AudioRecord类提供的三个获取声音数据的方法分别是read(byte[], int, int), read(short[], int, int), read(ByteBuffer, int). 无论选择使用那一个方法都必须事先设定方便用户的声音数据的存储格式。 　　开始录音的时候，AudioRecord需要初始化一个相关联的声音buffer, 这个buffer主要是用来保存新的声音数据。这个buffer的大小，我们可以在对象构造期间去指定。它表明一个AudioRecord对象还没有被读取（同步）声音数据前能录多长的音(即一次可以录制的声音容量)。声音数据从音频硬件中被读出，数据大小不超过整个录音数据的大小（可以分多次读出），即每次读取初始化buffer容量的数据。

实现Android录音的流程为：

  1. 构造一个AudioRecord对象，其中需要的最小录音缓存buffer大小可以通过getMinBufferSize方法得到。如果buffer容量过小，将导致对象构造的失败。
  2. 初始化一个buffer，该buffer大于等于AudioRecord对象用于写声音数据的buffer大小。
  3. 开始录音
  4. 创建一个数据流，一边从AudioRecord中读取声音数据到初始化的buffer，一边将buffer中数据导入数据流。
  5. 关闭数据流
  6. 停止录音

    二、使用 AudioRecord 实现录音，并生成wav

    2.1 创建一个AudioRecord对象

    首先要声明一些全局的变量参数：
    1. private AudioRecord audioRecord = null;  // 声明 AudioRecord 对象
    2. private int recordBufSize = 0; // 声明recoordBufffer的大小字段
    获取buffer的大小并创建AudioRecord：
    1. public void createAudioRecord() {
    2.  recordBufSize = AudioRecord.getMinBufferSize(frequency, channelConfiguration, EncodingBitRate);  //audioRecord能接受的最小的buffer大小
    3.  audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, frequency, channelConfiguration, EncodingBitRate, recordBufSize);
    4. }

    2.2 初始化一个buffer

    1. byte data[] = new byte[recordBufSize];

    2.3 开始录音

    1. audioRecord.startRecording();
    2. isRecording = true;

    2.4 创建一个数据流，一边从AudioRecord中读取声音数据到初始化的buffer，一边将buffer中数据导入数据流。

    1. FileOutputStream os = null;
    2. try {
    3.  os = new FileOutputStream(filename);
    4. } catch (FileNotFoundException e) {
    5.  e.printStackTrace();
    6. }
    7. if (null != os) {
    8.  while (isRecording) {
    9.      read = audioRecord.read(data, 0, recordBufSize);
    10.    // 如果读取音频数据没有出现错误，就将数据写入到文件
    11.      if (AudioRecord.ERROR_INVALID_OPERATION != read) {
    12.          try {
    13.              os.write(data);
    14.          } catch (IOException e) {
    15.              e.printStackTrace();
    16.          }
    17.      }
    18.  }
    19.  try {
    20.      os.close();
    21.  } catch (IOException e) {
    22.      e.printStackTrace();
    23.  }
    24. }

    2.5 关闭数据流

    修改标志位：isRecording 为false，上面的while循环就自动停止了，数据流也就停止流动了，Stream也就被关闭了。
    1. isRecording = false;

    2.6 停止录音

    停止录音之后，注意要释放资源。
    1. if (null != audioRecord) {
    2.  audioRecord.stop();
    3.  audioRecord.release();
    4.  audioRecord = null;
    5.  recordingThread = null;
    6. }
    注：权限需求：WRITE_EXTERNAL_STORAGE、RECORD_AUDIO
    到现在基本的录音的流程就介绍完了。但是这时候，有人就提出问题来了：
    1)、我按照流程，把音频数据都输出到文件里面了，停止录音后，打开此文件，发现不能播放，到底是为什么呢？
    答：按照流程走完了，数据是进去了，但是现在的文件里面的内容仅仅是最原始的音频数据，术语称为raw（中文解释是“原材料”或“未经处理的东西”），这时候，你让播放器去打开，它既不知道保存的格式是什么，又不知道如何进行解码操作。当然播放不了。
    2)、那如何才能在播放器中播放我录制的内容呢？
    答： 在文件的数据开头加入WAVE HEAD数据即可，也就是文件头。只有加上文件头部的数据，播放器才能正确的知道里面的内容到底是什么，进而能够正常的解析并播放里面的内容。具体的头文件的描述，在Play a WAV file on an AudioTrack里面可以进行了解。
    添加WAVE文件头的代码如下：
    1. public class PcmToWavUtil {
    2.  /**
    3.   * 缓存的音频大小
    4.   */
    5.  private int mBufferSize;
    6.  /**
    7.   * 采样率
    8.   */
    9.  private int mSampleRate;
    10.  /**
    11.   * 声道数
    12.   */
    13.  private int mChannel;
    14.  /**
    15.   * @param sampleRate sample rate、采样率
    16.   * @param channel channel、声道
    17.   * @param encoding Audio data format、音频格式
    18.   */
    19.  PcmToWavUtil(int sampleRate, int channel, int encoding) {
    20.      this.mSampleRate = sampleRate;
    21.      this.mChannel = channel;
    22.      this.mBufferSize = AudioRecord.getMinBufferSize(mSampleRate, mChannel, encoding);
    23.  }
    24.  /**
    25.   * pcm文件转wav文件
    26.   *
    27.   * @param inFilename 源文件路径
    28.   * @param outFilename 目标文件路径
    29.   */
    30.  public void pcmToWav(String inFilename, String outFilename) {
    31.      FileInputStream in;
    32.      FileOutputStream out;
    33.      long totalAudioLen;
    34.      long totalDataLen;
    35.      long longSampleRate = mSampleRate;
    36.      int channels = mChannel == AudioFormat.CHANNEL_IN_MONO ? 1 : 2;
    37.      long byteRate = 16 * mSampleRate * channels / 8;
    38.      byte[] data = new byte[mBufferSize];
    39.      try {
    40.          in = new FileInputStream(inFilename);
    41.          out = new FileOutputStream(outFilename);
    42.          totalAudioLen = in.getChannel().size();
    43.          totalDataLen = totalAudioLen + 36;
    44.          writeWaveFileHeader(out, totalAudioLen, totalDataLen,
    45.              longSampleRate, channels, byteRate);
    46.          while (in.read(data) != -1) {
    47.              out.write(data);
    48.          }
    49.          in.close();
    50.          out.close();
    51.      } catch (IOException e) {
    52.          e.printStackTrace();
    53.      }
    54.  }
    55.  /**
    56.   * 加入wav文件头
    57.   */
    58.  private void writeWaveFileHeader(FileOutputStream out, long totalAudioLen,
    59.                                   long totalDataLen, long longSampleRate, int channels, long byteRate)
    60.      throws IOException {
    61.      byte[] header = new byte[44];
    62.      // RIFF/WAVE header
    63.      header[0] = 'R';
    64.      header[1] = 'I';
    65.      header[2] = 'F';
    66.      header[3] = 'F';
    67.      header[4] = (byte) (totalDataLen & 0xff);
    68.      header[5] = (byte) ((totalDataLen >> 8) & 0xff);
    69.      header[6] = (byte) ((totalDataLen >> 16) & 0xff);
    70.      header[7] = (byte) ((totalDataLen >> 24) & 0xff);
    71.      //WAVE
    72.      header[8] = 'W';
    73.      header[9] = 'A';
    74.      header[10] = 'V';
    75.      header[11] = 'E';
    76.      // 'fmt ' chunk
    77.      header[12] = 'f';
    78.      header[13] = 'm';
    79.      header[14] = 't';
    80.      header[15] = ' ';
    81.      // 4 bytes: size of 'fmt ' chunk
    82.      header[16] = 16;
    83.      header[17] = 0;
    84.      header[18] = 0;
    85.      header[19] = 0;
    86.      // format = 1
    87.      header[20] = 1;
    88.      header[21] = 0;
    89.      header[22] = (byte) channels;
    90.      header[23] = 0;
    91.      header[24] = (byte) (longSampleRate & 0xff);
    92.      header[25] = (byte) ((longSampleRate >> 8) & 0xff);
    93.      header[26] = (byte) ((longSampleRate >> 16) & 0xff);
    94.      header[27] = (byte) ((longSampleRate >> 24) & 0xff);
    95.      header[28] = (byte) (byteRate & 0xff);
    96.      header[29] = (byte) ((byteRate >> 8) & 0xff);
    97.      header[30] = (byte) ((byteRate >> 16) & 0xff);
    98.      header[31] = (byte) ((byteRate >> 24) & 0xff);
    99.      // block align
    100.      header[32] = (byte) (2 * 16 / 8);
    101.      header[33] = 0;
    102.      // bits per sample
    103.      header[34] = 16;
    104.      header[35] = 0;
    105.      //data
    106.      header[36] = 'd';
    107.      header[37] = 'a';
    108.      header[38] = 't';
    109.      header[39] = 'a';
    110.      header[40] = (byte) (totalAudioLen & 0xff);
    111.      header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
    112.      header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
    113.      header[43] = (byte) ((totalAudioLen >> 24) & 0xff);
    114.      out.write(header, 0, 44);
    115.  }
    116. }

    三、附言

    Android SDK 提供了两套音频采集的API，分别是：MediaRecorder 和 AudioRecord，前者是一个更加上层一点的API，它可以直接把手机麦克风录入的音频数据进行编码压缩（如AMR、MP3等）并存成文件，而后者则更接近底层，能够更加自由灵活地控制，可以得到原始的一帧帧PCM音频数据。如果想简单地做一个录音机，录制成音频文件，则推荐使用 MediaRecorder，而如果需要对音频做进一步的算法处理、或者采用第三方的编码库进行压缩、以及网络传输等应用，则建议使用 AudioRecord，其实 MediaRecorder 底层也是调用了 AudioRecord 与 Android Framework 层的 AudioFlinger 进行交互的。直播中实时采集音频自然是要用AudioRecord了。

    四、源码

    https://github.com/renhui/AudioDemo