Android P的音频架构
音频架构图
谷歌官网：https://source.android.com/devices/audio
在谷歌官网介绍的音频架构中，我们可以看到下面的架构图：
android p音频处理流程
通过用AudioTrack来播放pcm格式音乐的流程，来讲解整个音频架构处理的流程。
android p音频播放从app开始，在framework层创建播放器，在audio library层做音频流和输出流控制，在Hal层将音频数据写入到输出设备进行声音输出。其中audio library层是音频处理的核心。
App --> Frameworks --> Audio Library --> HAL
一、App层
上层应用，包括各种音乐播放器，语音播报等声音输出软件。在app层，应用播放不同的音频文件。播放音频文件主要有两种方式，MediaPlayer和AudioTrack，这两者都提供了Java API供应用开发者使用，虽然都可以播放音频，但他们还是有区别：
1.MediaPlayer可以播放多种格式的声音文件，例如MP3，AAC，WAV，OGG，MIDI等。MediaPlayer会在framework层创建对应的音频解码器。
2.AudioTrack只能播放已经解码的PCM流，如果对比支持的文件格式的话则是AudioTrack只支持wav格式的音频文件，因为wav格式的音频文件大部分都是PCM流。AudioTrack不创建解码器，所以只能播放不需要解码的wav文件。
3.MediaPlayer在framework层还是会创建AudioTrack，把解码后的PCM数流传递给AudioTrack，AudioTrack再传递给AudioFlinger进行混音，然后才传递给硬件播放,所以是MediaPlayer包含了AudioTrack。
总结：MediaPlayer 更加适合在后台长时间播放本地音乐文件或者在线的流式资源；AudioTrack 则更接近底层，提供了非常强大的控制能力，支持低延迟播放，适合流媒体和VoIP语音电话等场景。
本文主要讲解使用AudioTrack播放pcm或者wav格式音频文件：
// 一个使用AudioTrack播放音频的简单例子
public class MainActivity extends Activity {
private Button mPlayBtn; //播放按钮
private Button mPauseBtn; //暂停按钮
private byte[] mAudioData; //音频数据
private AudioTrack mAudioTrack; //AudioTrack对象
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mPlayBtn = findViewById(R.id.play);
mPauseBtn = findViewById(R.id.pause);
mPlayBtn.setEnabled(false);
//按下播放按钮后做的处理
mPlayBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mPlayBtn.setEnabled(false);
if(mAudioTrack != null){
mAudioTrack.play();
}else{
// android p之前的版本初始化AudioTrack的方式，在android p中遗弃了该方式，但是兼容这种写法。
// mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT,mAudioData.length, AudioTrack.MODE_STATIC);
// android p初始化AudioTrack的方式
/* 音频参数(音频参数如果跟音频文件参数不一致，声音播放会出现异常):
* streamType:音频流类型 AudioManager.STREAM_MUSIC,音乐（不同的声音分类为不同的音频流类型）
* encoding:位宽 AudioFormat.ENCODING_PCM_16BIT,16bit音频文件
* sampleRate：采样率 8000,8k的音频文件
* channelMask:通道数 AudioFormat.CHANNEL_OUT_MONO,单声道
*/
AudioAttributes.Builder attr = (new AudioAttributes.Builder())
.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
.setLegacyStreamType(AudioManager.STREAM_MUSIC)
.setFlags(AudioAttributes.FLAG_AUDIBILITY_ENFORCED)
.setUsage(AudioAttributes.USAGE_MEDIA);
AudioFormat.Builder format = (new AudioFormat.Builder())
.setEncoding(AudioFormat.ENCODING_PCM_16BIT)
.setSampleRate(8000)
.setChannelMask( AudioFormat.CHANNEL_OUT_MONO);
/* AudioTrack 创建模式mode
* AudioTrack.MODE_STATIC:播放音频前一次性将全部的音频数据从java传递到native层
* AudioTrack.MODE_STREAM:播放音频时将音频数据用数据流的方式从java传递到native层
*/
mAudioTrack = new AudioTrack(attr.build(), format.build(), mAudioData.length, AudioTrack.MODE_STATIC,AudioManager.AUDIO_SESSION_ID_GENERATE);
mAudioTrack.write(mAudioData, 0, mAudioData.length);
mAudioTrack.play();
}
}
});
mPauseBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(mAudioTrack != null){
mAudioTrack.pause();
}
mPlayBtn.setEnabled(true);
}
});
//用一个异步任务将音频数据读出来
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
try {
//音频文件放在res/raw/目录下
InputStream in = getResources().openRawResource(R.raw.bingyu);
try {
//读出音频流数据
ByteArrayOutputStream out = new ByteArrayOutputStream(in.available());
for (int b; (b = in.read()) != -1;) {
out.write(b);
}
mAudioData = out.toByteArray();
} finally {
in.close();
}
} catch (IOException e) {
}
return null;
}
@Override
protected void onPostExecute(Void v) {
mPlayBtn.setEnabled(true);
}
}.execute();
}
//释放AudioTrack资源
private void releaseAudioTrack() {
if (mAudioTrack != null) {
mAudioTrack.stop();
mAudioTrack.release();
mAudioTrack = null;
}
}
@Override
protected void onStop() {
super.onStop();
releaseAudioTrack();
}
@Override
protected void onDestroy() {
super.onDestroy();
releaseAudioTrack();
}
}具体代码项目地址：https://github.com/sunxiaolin2016/Android-Audio
二、Frameworks层
Frameworks层相关代码：frameworks/base/media/java/android/media/
在app中创建AudioTrack的过程中，比较关键的一段代码为：
mAudioTrack = new AudioTrack(attr.build(), format.build(), mAudioData.length, AudioTrack.MODE_STATIC,AudioManager.AUDIO_SESSION_ID_GENERATE);
这段代码将在/frameworks/base/media/java/android/media/AudioTrack.java中做初始化，接下来我们来看AudioTrack中代码：
private AudioTrack(AudioAttributes attributes, AudioFormat format, int bufferSizeInBytes,
int mode, int sessionId, boolean offload) throws IllegalArgumentException {
super(attributes, AudioPlaybackConfiguration.PLAYER_TYPE_JAM_AUDIOTRACK);
//省略一部分代码
...
/* native层初始化
* 这里调用了jni代码，/frameworks/base/core/jni/android_media_AudioTrack.cpp中android_media_AudioTrack_setup()函数
* 最终将调用Audio Library层，frameworks/av/media/libaudioclient/AudioTrack.cpp,创建native AudioTrack object
* 在Audio Library层，将执行lpTrack->set(...)函数，后面将详细讲解set()函数
*/
// native initialization
int initResult = native_setup(new WeakReference<AudioTrack>(this), mAttributes,
sampleRate, mChannelMask, mChannelIndexMask, mAudioFormat,
mNativeBufferSizeInBytes, mDataLoadMode, session, 0 /*nativeTrackInJavaObj*/,
offload);
if (initResult != SUCCESS) {
loge("Error code "+initResult+" when initializing AudioTrack.");
return; // with mState == STATE_UNINITIALIZED
}
//省略一部分代码
...
}三、Audio Library层
Library层相关代码：frameworks/av/
Audio Library层是音频处理的核心，主要分为三个部分：AudioTrack，AudioFlinger和AudioPlicy：
- AudioTrack：负责回放数据的输出;
- AudioFlinger：音频策略的执行者，负责输入输出流设备的管理及音频流数据的传输处理;
- AudioPolicy：音频策略的制定者，负责音频设备切换的策略抉择、音量调节策略等;
AudioTrack.cpp所在目录： frameworks/av/media/libaudioclient/
这部分内容被编译成库libaudioclient.so文件。
AudioFlinger.cpp所在目录：frameworks/av/services/audioflinger/
这部分内容被编译成库libaudioflinger.so文件。
AudioPolicyManager.cpp所在目录：frameworks/av/services/audiopolicy/
这部分内容被编译成库libaudioflinger.so文件。
AudioTrack和AudioFlinger的交互原理：
- audiotrackcblk_t实现了一个环形FIFO；
- AudioTrack是FIFO的数据生产者；
- AudioFlinger是FIFO的数据消费者。
下面这张图很好的解释了AudioTrack和AudioFlinger之间的交互关系：
了解了交互原理之后，下面我们来分析一下具体的代码：
AudioTrack.cpp分析：
在frameworks层代码讲到，new AudioTrack()最终会创建生成一个native 的AudioTrack对象，并且执行Set()函数，代码如下：
status_t AudioTrack::set()
{
//省略一部分代码
...
// 这里执行了createTrack_l(),接下来我们看createTrack_l()的处理
// create the IAudioTrack
status = createTrack_l();
//省略一部分代码
...
}
status_t AudioTrack::createTrack_l()
{
//省略一部分代码
...
//音频流类型，音频的采样率等信息放进了input里面
IAudioFlinger::CreateTrackInput input;
if (mStreamType != AUDIO_STREAM_DEFAULT) {
stream_type_to_audio_attributes(mStreamType, &input.attr);
} else {
input.attr = mAttributes;
}
input.config = AUDIO_CONFIG_INITIALIZER;
input.config.sample_rate = mSampleRate;
input.config.channel_mask = mChannelMask;
input.config.format = mFormat;
input.config.offload_info = mOffloadInfoCopy;
input.clientInfo.clientUid = mClientUid;
input.clientInfo.clientPid = mClientPid;
input.clientInfo.clientTid = -1;
//省略一部分代码
...
//跟AudioFlinger进行交互，返回一个Track句柄，可以进行play,pause等控制操作
//通过track->getCblk();得到在AudioFlinger中创建的FIFO(audiotrackcblk_t);
sp<IAudioTrack> track = audioFlinger->createTrack(input,
output,
&status);
if (status != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
ALOGE("AudioFlinger could not create track, status: %d output %d", status, output.outputId);
if (status == NO_ERROR) {
status = NO_INIT;
}
goto exit;
}
//省略一部分代码
...
}AudioFlinger.cpp文件分析：
AudioTrack.cpp会通过Binder调用AudioFlinger.cpp中的createTrack()函数，代码如下：
// IAudioFlinger interface
sp<IAudioTrack> AudioFlinger::createTrack(const CreateTrackInput& input,
CreateTrackOutput& output,
status_t *status)
{
//省略一部分代码
...
/* AudioSystem::getOutputForAttr() 经过一系列的调用，进入 AudioPolicyManager::getOutputForDevice()
* 最终调用 AudioFlinger::openOutput() 根据音频策略，打开输出标识对应的输出流设备并创建相关的PlaybackThread,
* 并保存该 PlaybackThread 对应的 audio_io_handle_t 给 AudioTrack；
*/
lStatus = AudioSystem::getOutputForAttr(&input.attr, &output.outputId, sessionId, &streamType,
clientPid, clientUid, &input.config, input.flags,
&output.selectedDeviceId, &portId);
if (lStatus != NO_ERROR || output.outputId == AUDIO_IO_HANDLE_NONE) {
ALOGE("createTrack() getOutputForAttr() return error %d or invalid output handle", lStatus);
goto Exit;
}
//省略一部分代码
...
//根据outputId获取相对应的音频回放线程，音频数据的读写主要在这个PlaybackThread中进行
Mutex::Autolock _l(mLock);
PlaybackThread *thread = checkPlaybackThread_l(output.outputId);
if (thread == NULL) {
ALOGE("no playback thread found for output handle %d", output.outputId);
lStatus = BAD_VALUE;
goto Exit;
}
client = registerPid(clientPid);
PlaybackThread *effectThread = NULL;
// check if an effect chain with the same session ID is present on another
// output thread and move it here.
for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
if (mPlaybackThreads.keyAt(i) != output.outputId) {
uint32_t sessions = t->hasAudioSession(sessionId);
if (sessions & ThreadBase::EFFECT_SESSION) {
effectThread = t.get();
break;
}
}
}
ALOGV("createTrack() sessionId: %d", sessionId);
output.sampleRate = input.config.sample_rate;
output.frameCount = input.frameCount;
output.notificationFrameCount = input.notificationFrameCount;
output.flags = input.flags;
//这里创建了一个track并最终返回给AudioTrack.cpp中
track = thread->createTrack_l(client, streamType, input.attr, &output.sampleRate,
input.config.format, input.config.channel_mask,
&output.frameCount, &output.notificationFrameCount,
input.notificationsPerBuffer, input.speed,
input.sharedBuffer, sessionId, &output.flags,
input.clientInfo.clientTid, clientUid, &lStatus, portId);
//省略一部分代码
...
}
//接下来我们来看PlaybackThread::createTrack_l中做了哪些处理
// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
const sp<AudioFlinger::Client>& client,
audio_stream_type_t streamType,
const audio_attributes_t& attr,
uint32_t *pSampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
size_t *pFrameCount,
size_t *pNotificationFrameCount,
uint32_t notificationsPerBuffer,
float speed,
const sp<IMemory>& sharedBuffer,
audio_session_t sessionId,
audio_output_flags_t *flags,
pid_t tid,
uid_t uid,
status_t *status,
audio_port_handle_t portId)
{
//省略一部分代码
...
//创建了一个Track对象
//核心代码为Track的构造函数，下面我们看看Track的构造函数做了哪些处理
track = new Track(this, client, streamType, attr, sampleRate, format,
channelMask, frameCount,
nullptr /* buffer */, (size_t)0 /* bufferSize */, sharedBuffer,
sessionId, uid, *flags, TrackBase::TYPE_DEFAULT, portId);
//省略一部分代码
...
}
// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
AudioFlinger::PlaybackThread::Track::Track(...)
{
//省略一部分代码
...
if (sharedBuffer == 0) {
/* MODE_STREAM
* AudioTrack创建时，数据传输模式为 MODE_STREAM 模式，创建一个 AudioTrackServerProxy 对象,
* PlaybackThread 将持续使用它从 FIFO 上取得可读数据的位置.
*/
mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
mFrameSize, !isExternalTrack(), sampleRate);
} else {
/* MODE_STATIC
* AudioTrack创建时，数据传输模式为 MODE_STREAM 模式，创建一个 AudioTrackServerProxy 对象,
* PlaybackThread 将持续使用它从 FIFO 上取得可读数据的位置.
*/
mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
mFrameSize);
}
mServerProxy = mAudioTrackServerProxy;
//省略一部分代码
...
}到这里，整个从AudioTrack到AudioFlinger之间的流程都走下来了。其中还有一些细节，后面在慢慢分析，关于AudioPolicy的音频策略管理部分，我们放到下一章节在讲。
四、HAL层
HAL是AudioFlinger直接访问的对象，AudioFlingerd打开HAL层的输出流设备后，将从FIFO中读到的音频数据发送HAL层，由HAL层输出到硬件设备中进行声音输出。这一点后面在单独发文章出来分析。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
