音頻播放
音頻播放聲音分為MediaPlayer和AudioTrack兩種方案的。MediaPlayer可以播放多種格式的聲音文件，例如MP3，WAV，OGG，AAC，MIDI等。然而AudioTrack只能播放PCM數據流。當然兩者之間還是有緊密的聯系，MediaPlayer在播放音頻時，在framework層還是會創建AudioTrack，把解碼后的PCM數流傳遞給AudioTrack，最后由AudioFlinger進行混音，傳遞音頻給硬件播放出來。利用AudioTrack播放只是跳過Mediaplayer的解碼部分而已。
AudioTrack作用
AudioTrack是管理和播放單一音頻資源的類。AudioTrack僅僅能播放已經解碼的PCM流，用于PCM音頻流的回放。
AudioTrack實現PCM音頻播放
AudioTrack實現PCM音頻播放五步走
- 配置基本參數
- 獲取最小緩沖區大小
- 創建AudioTrack對象
- 獲取PCM文件，轉成DataInputStream
- 開啟/停止播放
直接上代碼再分析
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
public class AudioTrackManager {
private AudioTrack mAudioTrack;
private DataInputStream mDis;//播放文件的數據流
private Thread mRecordThread;
private boolean isStart = false;
private volatile static AudioTrackManager mInstance;
//音頻流類型
private static final int mStreamType = AudioManager.STREAM_MUSIC;
//指定采樣率 （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 mMinBufferSize;
//STREAM的意思是由用戶在應用程序通過write方式把數據一次一次得寫到audiotrack中。這個和我們在socket中發送數據一樣，
// 應用層從某個地方獲取數據，例如通過編解碼得到PCM數據，然后write到audiotrack。
private static int mMode = AudioTrack.MODE_STREAM;
public AudioTrackManager() {
initData();
}
private void initData(){
//根據采樣率，采樣精度，單雙聲道來得到frame的大小。
mMinBufferSize = AudioTrack.getMinBufferSize(mSampleRateInHz,mChannelConfig, mAudioFormat);//計算最小緩沖區
//注意，按照數字音頻的知識，這個算出來的是一秒鐘buffer的大小。
//創建AudioTrack
mAudioTrack = new AudioTrack(mStreamType, mSampleRateInHz,mChannelConfig,
mAudioFormat,mMinBufferSize,mMode);
}
/**
* 獲取單例引用
*
* @return
*/
public static AudioTrackManager getInstance() {
if (mInstance == null) {
synchronized (AudioTrackManager.class) {
if (mInstance == null) {
mInstance = new AudioTrackManager();
}
}
}
return mInstance;
}
/**
* 銷毀線程方法
*/
private void destroyThread() {
try {
isStart = false;
if (null != mRecordThread && Thread.State.RUNNABLE == mRecordThread.getState()) {
try {
Thread.sleep(500);
mRecordThread.interrupt();
} catch (Exception e) {
mRecordThread = null;
}
}
mRecordThread = null;
} catch (Exception e) {
e.printStackTrace();
} finally {
mRecordThread = null;
}
}
/**
* 啟動播放線程
*/
private void startThread() {
destroyThread();
isStart = true;
if (mRecordThread == null) {
mRecordThread = new Thread(recordRunnable);
mRecordThread.start();
}
}
/**
* 播放線程
*/
Runnable recordRunnable = new Runnable() {
@Override
public void run() {
try {
//設置線程的優先級
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);
byte[] tempBuffer = new byte[mMinBufferSize];
int readCount = 0;
while (mDis.available() > 0) {
readCount= mDis.read(tempBuffer);
if (readCount == AudioTrack.ERROR_INVALID_OPERATION || readCount == AudioTrack.ERROR_BAD_VALUE) {
continue;
}
if (readCount != 0 && readCount != -1) {//一邊播放一邊寫入語音數據
//判斷AudioTrack未初始化，停止播放的時候釋放了，狀態就為STATE_UNINITIALIZED
if(mAudioTrack.getState() == mAudioTrack.STATE_UNINITIALIZED){
initData();
}
mAudioTrack.play();
mAudioTrack.write(tempBuffer, 0, readCount);
}
}
stopPlay();//播放完就停止播放
} catch (Exception e) {
e.printStackTrace();
}
}
};
/**
* 播放文件
* @param path
* @throws Exception
*/
private void setPath(String path) throws Exception {
File file = new File(path);
mDis = new DataInputStream(new FileInputStream(file));
}
/**
* 啟動播放
*
* @param path
*/
public void startPlay(String path) {
try {
// //AudioTrack未初始化
// if(mAudioTrack.getState() == AudioTrack.STATE_UNINITIALIZED){
// throw new RuntimeException("The AudioTrack is not uninitialized");
// }//AudioRecord.getMinBufferSize的參數是否支持當前的硬件設備
// else if (AudioTrack.ERROR_BAD_VALUE == mMinBufferSize || AudioTrack.ERROR == mMinBufferSize) {
// throw new RuntimeException("AudioTrack Unable to getMinBufferSize");
// }else{
setPath(path);
startThread();
// }
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 停止播放
*/
public void stopPlay() {
try {
destroyThread();//銷毀線程
if (mAudioTrack != null) {
if (mAudioTrack.getState() == AudioRecord.STATE_INITIALIZED) {//初始化成功
mAudioTrack.stop();//停止播放
}
if (mAudioTrack != null) {
mAudioTrack.release();//釋放audioTrack資源
}
}
if (mDis != null) {
mDis.close();//關閉數據輸入流
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
配置基本參數
-
StreamType音頻流類型
最主要的幾種STREAM
- AudioManager.STREAM_MUSIC：用于音樂播放的音頻流。
- AudioManager.STREAM_SYSTEM：用于系統聲音的音頻流。
- AudioManager.STREAM_RING：用于電話鈴聲的音頻流。
- AudioManager.STREAM_VOICE_CALL：用于電話通話的音頻流。
- AudioManager.STREAM_ALARM：用于警報的音頻流。
- AudioManager.STREAM_NOTIFICATION：用于通知的音頻流。
- AudioManager.STREAM_BLUETOOTH_SCO：用于連接到藍牙電話時的手機音頻流。
- AudioManager.STREAM_SYSTEM_ENFORCED：在某些國家實施的系統聲音的音頻流。
- AudioManager.STREAM_DTMF：DTMF音調的音頻流。
- AudioManager.STREAM_TTS：文本到語音轉換（TTS）的音頻流。
為什么分那么多種類型，其實原因很簡單，比如你在聽music的時候接到電話，這個時候music播放肯定會停止，此時你只能聽到電話，如果你調節音量的話，這個調節肯定只對電話起作用。當電話打完了，再回到music，你肯定不用再調節音量了。
其實系統將這幾種聲音的數據分開管理，STREAM參數對AudioTrack來說，它的含義就是告訴系統，我現在想使用的是哪種類型的聲音，這樣系統就可以對應管理他們了。
-
MODE模式（static和stream兩種）
-
AudioTrack.MODE_STREAM
STREAM的意思是由用戶在應用程序通過write方式把數據一次一次得寫到AudioTrack中。這個和我們在socket中發送數據一樣，應用層從某個地方獲取數據，例如通過編解碼得到PCM數據，然后write到AudioTrack。這種方式的壞處就是總是在JAVA層和Native層交互，效率損失較大。
-
AudioTrack.MODE_STATIC
STATIC就是數據一次性交付給接收方。好處是簡單高效，只需要進行一次操作就完成了數據的傳遞;缺點當然也很明顯，對于數據量較大的音頻回放，顯然它是無法勝任的，因而通常只用于播放鈴聲、系統提醒等對內存小的操作
-
-
采樣率：mSampleRateInHz
采樣率 （MediaRecoder 的采樣率通常是8000Hz AAC的通常是44100Hz。 設置采樣率為44100，目前為常用的采樣率，官方文檔表示這個值可以兼容所有的設置）
-
通道數目：mChannelConfig
首先得出聲道數，目前最多只支持雙聲道。為什么最多只支持雙聲道？看下面的源碼
static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat) { int channelCount = 0; switch(channelConfig) { case AudioFormat.CHANNEL_OUT_MONO: case AudioFormat.CHANNEL_CONFIGURATION_MONO: channelCount = 1; break; case AudioFormat.CHANNEL_OUT_STEREO: case AudioFormat.CHANNEL_CONFIGURATION_STEREO: channelCount = 2; break; default: if (!isMultichannelConfigSupported(channelConfig)) { loge("getMinBufferSize(): Invalid channel configuration."); return ERROR_BAD_VALUE; } else { channelCount = AudioFormat.channelCountFromOutChannelMask(channelConfig); } } ....... ｝ -
音頻量化位數：mAudioFormat（只支持8bit和16bit兩種。）
if ((audioFormat !=AudioFormat.ENCODING_PCM_16BIT) && (audioFormat !=AudioFormat.ENCODING_PCM_8BIT)) { returnAudioTrack.ERROR_BAD_VALUE; }
最小緩沖區大小
mMinBufferSize取決于采樣率、聲道數和采樣深度三個屬性,那么具體是如何計算的呢？我們看一下源碼
static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat) {
....
int size = native_get_min_buff_size(sampleRateInHz, channelCount, audioFormat);
if (size <= 0) {
loge("getMinBufferSize(): error querying hardware");
return ERROR;
}
else {
return size;
}
}
看到源碼緩沖區的大小的實現在nativen層中，接著看下native層代碼實現：
rameworks/base/core/jni/android_media_AudioTrack.cpp
static jint android_media_AudioTrack_get_min_buff_size(JNIEnv*env, jobject thiz,
jint sampleRateInHertz,jint nbChannels, jint audioFormat) {
int frameCount = 0;
if(AudioTrack::getMinFrameCount(&frameCount, AUDIO_STREAM_DEFAULT,sampleRateInHertz) != NO_ERROR) {
return -1;
}
return frameCount * nbChannels * (audioFormat ==javaAudioTrackFields.PCM16 ? 2 : 1);
}
這里又調用了getMinFrameCount，這個函數用于確定至少需要多少Frame才能保證音頻正常播放。那么Frame代表了什么意思呢？可以想象一下視頻中幀的概念，它代表了某個時間點的一幅圖像。這里的Frame也是類似的，它應該是指某個特定時間點時的音頻數據量，所以android_media_AudioTrack_get_min_buff_size中最后采用的計算公式就是：
至少需要多少幀每幀數據量 = frameCount * nbChannels * (audioFormat ==javaAudioTrackFields.PCM16 ? 2 : 1);
公式中frameCount就是需要的幀數，每一幀的數據量又等于：
Channel數每個Channel數據量= nbChannels * (audioFormat ==javaAudioTrackFields.PCM16 ? 2 : 1)層層返回getMinBufferSize就得到了保障AudioTrack正常工作的最小緩沖區大小了。
創建AudioTrack對象
取到mMinBufferSize后，我們就可以創建一個AudioTrack對象了。它的構造函數原型是：
public AudioTrack(int streamType, int sampleRateInHz, int channelConfig, int audioFormat,
int bufferSizeInBytes, int mode)
throws IllegalArgumentException {
this(streamType, sampleRateInHz, channelConfig, audioFormat,
bufferSizeInBytes, mode, AudioManager.AUDIO_SESSION_ID_GENERATE);
}
在源碼中一層層往下看
public AudioTrack(AudioAttributes attributes, AudioFormat format, int bufferSizeInBytes,
int mode, int sessionId)
throws IllegalArgumentException {
super(attributes, AudioPlaybackConfiguration.PLAYER_TYPE_JAM_AUDIOTRACK);
.....
// native initialization
int initResult = native_setup(new WeakReference<AudioTrack>(this), mAttributes,
sampleRate, mChannelMask, mChannelIndexMask, mAudioFormat,
mNativeBufferSizeInBytes, mDataLoadMode, session, 0 /*nativeTrackInJavaObj*/);
if (initResult != SUCCESS) {
loge("Error code "+initResult+" when initializing AudioTrack.");
return; // with mState == STATE_UNINITIALIZED
}
mSampleRate = sampleRate[0];
mSessionId = session[0];
if (mDataLoadMode == MODE_STATIC) {
mState = STATE_NO_STATIC_DATA;
} else {
mState = STATE_INITIALIZED;
}
baseRegisterPlayer();
}
最終看到了又在native_setup方法中，在native中initialization，看看實現些什么了
/*frameworks/base/core/jni/android_media_AudioTrack.cpp*/
static int android_media_AudioTrack_native_setup(JNIEnv*env, jobject thiz, jobject weak_this,
jint streamType, jintsampleRateInHertz, jint javaChannelMask,
jint audioFormat, jintbuffSizeInBytes, jint memoryMode, jintArray jSession)
{
.....
sp<AudioTrack>lpTrack = new AudioTrack();
.....
AudioTrackJniStorage* lpJniStorage =new AudioTrackJniStorage();
這里調用了native_setup來創建一個本地AudioTrack對象，創建一個Storage對象，從這個Storage猜測這可能是存儲音頻數據的地方，我們再進入了解這個Storage對象。
if (memoryMode== javaAudioTrackFields.MODE_STREAM) {
lpTrack->set(
...
audioCallback, //回調函數
&(lpJniStorage->mCallbackData),//回調數據
0,
0,//shared mem
true,// thread cancall Java
sessionId);//audio session ID
} else if (memoryMode ==javaAudioTrackFields.MODE_STATIC) {
...
lpTrack->set(
...
audioCallback, &(lpJniStorage->mCallbackData),0,
lpJniStorage->mMemBase,// shared mem
true,// thread cancall Java
sessionId);//audio session ID
}
....// native_setup結束
調用set函數為AudioTrack設置這些屬性——我們只保留兩種內存模式(STATIC和STREAM)有差異的地方，入參中的倒數第三個是lpJniStorage->mMemBase，而STREAM類型時為null(0)。太深了，對于基礎的知識先研究到這里吧
獲取PCM文件，轉成DataInputStream
根據存放PCM的路徑獲取到PCM文件
/**
* 播放文件
* @param path
* @throws Exception
*/
private void setPath(String path) throws Exception {
File file = new File(path);
mDis = new DataInputStream(new FileInputStream(file));
}
開啟/停止播放
-
開始播放
public void play()throws IllegalStateException { if (mState != STATE_INITIALIZED) { throw new IllegalStateException("play() called on uninitialized AudioTrack."); } //FIXME use lambda to pass startImpl to superclass final int delay = getStartDelayMs(); if (delay == 0) { startImpl(); } else { new Thread() { public void run() { try { Thread.sleep(delay); } catch (InterruptedException e) { e.printStackTrace(); } baseSetStartDelayMs(0); try { startImpl(); } catch (IllegalStateException e) { // fail silently for a state exception when it is happening after // a delayed start, as the player state could have changed between the // call to start() and the execution of startImpl() } } }.start(); } } -
停止播放
停止播放音頻數據，如果是STREAM模式，會等播放完最后寫入buffer的數據才會停止。如果立即停止，要調用pause()方法，然后調用flush方法，會舍棄還沒有播放的數據。
public void stop()throws IllegalStateException { if (mState != STATE_INITIALIZED) { throw new IllegalStateException("stop() called on uninitialized AudioTrack."); } // stop playing synchronized(mPlayStateLock) { native_stop(); baseStop(); mPlayState = PLAYSTATE_STOPPED; mAvSyncHeader = null; mAvSyncBytesRemaining = 0; } } -
暫停播放
暫停播放，調用play()重新開始播放。
-
釋放本地AudioTrack資源
AudioTrack.release()
-
返回當前的播放狀態
AudioTrack.getPlayState()
注意: flush()只在模式為STREAM下可用。將音頻數據刷進等待播放的隊列，任何寫入的數據如果沒有提交的話，都會被舍棄，但是并不能保證所有用于數據的緩沖空間都可用于后續的寫入。
總結
- 播放一個PCM文件，按照上面的五步走。
- 注意參數有配置，如量化位數是8BIT還是16BIT等。
- 想更加了解AudioTrack里的方法就動手寫一個demo深入了解那些方法的用途。
- 能不能續播（還沒有驗證）
