音频学习笔记之音频采集

100 阅读 0 评论 66 点赞

我是靠谱客的博主听话黑猫，最近开发中收集的这篇文章主要介绍音频学习笔记之音频采集，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

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);
                    }
                }
            }
        }
    }
}

参考文献：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);
        }
    }