Android源码分析：AudioFlinger中的线程

本为转载自：

http://blog.redwolf-soft.com/?p=976

Android源码分析：AudioFlinger中的线程
红狼博客

 

Track相关类概述

下图是其继承关系图，继承在AudioBufferProvider之后，各种Track可以作为AudioBufferProvider的一种为AudioMixer提供音频数据缓冲。TrackBase是基类，Track作为普通的音轨类，用于音频播放；OutputTrack用于复制线程，相当于将声音同时输出到两个输出设备中。

TrackBase

在它的构造函数中，在ashm上为audio_track_cblk_t分配共享内存（即成员变量mCblk所指向的内存），用于应用程序和audioflinger所在的mediaserver进程进行通讯。若是在AudioTrack中指定了Stream mode（需要不断提供音频数据），那么还要为要写进来的数据分配共享内存，这块共享内存紧接在audio_track_cblk_t的后面，大小为：

size_t bufferSize = frameCount*channelCount*sizeof(int16_t);

下图是Stream模式下的共享内存示意图：

 

bufferSize

 

audio_track_cblk_t

mBuffer

mCblk

若是Static mdoe（如音频资源文件直接装载入，效率较高，如用于时间短的、多次使用的提示音），则使用传递进来的IMemory作为缓冲区，不需要在共享缓冲区上分配内存。成员变量mBuffer则指向这个缓冲区IMemory所代表的缓冲区。此种情况下，mCblk仍在构造函数中分配位于ashm中的内存。

应用程序和AudioFlinger通过mBuffer指向的缓冲区来共享音频数据。应用程序作为“生产者”写入音频数据到mBuffer中，同时改变mCblk里的成员值；AudioFlinger作为“消费者”消耗mBuffer里的音频数据。

releaseBuffer：audioflinger侧的释放缓冲区函数。得到缓冲区中的桢数后，调用step将计数server向前移动缓冲区所包含的桢数。

step：调用audio_track_cblk_t的stepServer将计数器向前移动指定的桢数。

reset：重置audio_track_cblk_t中的userBase和user、serverBase和server等计数为0

getBuffer：参数offset是基于serverBase的偏移桢数，参数frames是从开始offset计算的桢数，返回值是offset处的指针值。调用该函数表示需要获取offset处开始的、包含frames桢的一块缓冲区。

 

Track

构造函数：从所存在的线程中获取track的名称放置于mName中，注意此处的名称是一个整数，也是个索引，来自于AudioMixer。AudioMixer支持高达32路混音，这个名称就是track在这32个元素数组中的索引。在构造函数中，另一个要完成的是让Track的mMainBuffer指向track所在播放线程的mMixBuffer。在构造函数后面，计算一个桢的大小赋值给audio_track_cblk_t中的frameSize。

为了以示强调，下图示意出：Track的mMainBuffer指向track所在播放线程的mMixBuffer：

 

PlaybackThread

 

Track

 

mMainBuffer

mMixBuffer

 

 

若是有音效链，则被修改为指向音效链的输入buffer，见函数PlaybackThread::createTrack_l。

 

 

destroy：销毁自身。若不是OutputTrack（用于复制线程），则调用AudioSystem::stopOutput停止输出。如果是播放线程中的最后一个track，则还要调用AudioSystem::releaseOutput释放输出。

getNextBuffer：参照参数AudioBufferProvider::Buffer* buffer的请求中的桢数，尽可能以audio_track_cblk_t的framesReady为准，得到mBuffer中已经准备好（Ready）的音频数据缓冲区，让参数buffer的raw指针指向该准备好的数据块缓冲区。注意：根据偏移和请求的桢数，其调用了父类的getBuffer函数来获得缓冲区指针。

start函数：在进行状态检查和设置后，调用AudioSystem::startOutput开始播放，然后将自己添加到播放线程的mTracks列表中。开始由播放线程开始调度操作缓冲区。

stop/pause：调用AudioSystem::stopOutput停掉播放，二者状态被设置的不同

attachAuxEffect：参数EffectId是Effect的id号，它调用播放线程的同名函数，后者会在其编号为0（AudioSystem::SESSION_OUTPUT_MIX）的session中去查找具有该id号的Effect，并且要求是Auxiliary Effect，最后让Track的mAuxBuffer指向Effect的输入buffer即inBuffer。

 

OutputTrack

Track的子类，为DuplicatingThread线程所用，DuplicatingThread将混音好的数据写入到它里面，然后输出到两个output设备对应的mixer线程中，实现复制输出。

构造函数：为audio_track_cblk_t指定CBLK_DIRECTION_OUT标志，让mCblk中的buffers指向audio_track_cblk_t后面的缓冲区（因OutputTrack中不支持指定一个IMemory，所以mBuffer指向mCblk后面的缓冲区，即Stream模式）；最后将自己添加到播放线程中的mTracks中。

成员函数obtainBuffer: 获取mBuffer中一块空闲的缓冲区。缓冲区信息将填充到第一个参数AudioBufferProvider::Buffer* buffer中，填入的信息包括缓冲区地址和桢数。请求获得的桢数是第一个参数AudioBufferProvider::Buffer* buffer中的frameCount，但数量还决定于mBuffer中是否已有这么多空闲未用的缓冲区、以及截止mBuffer末尾处的最大桢数。第二个参数waitTimeMs表示当没有可用缓冲区时需要等待的超时时间。

成员函数write：将要写入的数据首先写到一个限定不超过10个节点的待写缓冲队列mBufferQueue上，再从待写缓冲队列上再将数据copy到mCblk后面的缓冲区即mBuffer中。每次拷贝操作，表面上是拷贝到mOutBuffer中。实际上mOutBuffer指向的是mBuffer中的空闲区域。当待写队列为空时，才会跳过待写队列，直接让write传递过来的数据写到mOutBuffer中。可见write的过程本质是将数据写到mBuffer中，但是添加了一个不超过10个节点的缓冲队列来临时存放write要写的数据，然后再copy过去。

函数write代码较多，分四部分来分析，第一部分代码让inBuffer指向参数传递进来的要写的数据，然后分配缓冲区内存（大小为mCblk->frameCount – frames桢），添加到队列mBufferQueue上：

bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames)
{
Buffer *pInBuffer;
Buffer inBuffer;
uint32_t channelCount = mCblk->channelCount;
bool outputBufferFull = false;
inBuffer.frameCount = frames;//此行及下面一行：inBuffer代表着要写入的数据
inBuffer.i16 = data;

uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();

if (!mActive && frames != 0) {//若不为active状态且要写入非空数据
start();//开始
sp<ThreadBase> thread = mThread.promote();
if (thread != 0) {//获取mixer线程
MixerThread *mixerThread = (MixerThread *)thread.get();
if (mCblk->frameCount > frames){//要写的frmaes数量不超过mCblk后面的缓冲区大小
if (mBufferQueue.size() < kMaxOverFlowBuffers) {//缓冲队列还没超限（10个）
uint32_t startFrames = (mCblk->frameCount – frames);
pInBuffer = new Buffer;
pInBuffer->mBuffer = new int16_t[startFrames * channelCount];//分配内存
pInBuffer->frameCount = startFrames;
pInBuffer->i16 = pInBuffer->mBuffer;
memset(pInBuffer->raw, 0, startFrames * channelCount * sizeof(int16_t));//分配的内存清零
mBufferQueue.add(pInBuffer);//添加到队列中
} else {//若是缓冲队列超限
LOGW (“OutputTrack::write() %p no more buffers in queue”, this);
}
}
}
}

第二部分代码是一个while循环，在剩下的等待时间里，将待写缓冲队列上的数据写到mOutBuffer在mCblk后面的mBuffer中所对应的空闲缓冲区中：

while (waitTimeLeftMs) {//若还有等待时间
// First write pending buffers, then new data
if (mBufferQueue.size()) {//检查缓冲队列是否为空
pInBuffer = mBufferQueue.itemAt(0);//从队列上取下第一个节点，作为待写入的数据
} else {
pInBuffer = &inBuffer;//没有的话，直接使用参数传递来的作为待写数据
}
if (pInBuffer->frameCount == 0) {
break;//都为空，退出while循环
}

if (mOutBuffer.frameCount == 0) {//若mOutBuffer在mCblk后面没有对应的缓冲区，即要写入的目的地
mOutBuffer.frameCount = pInBuffer->frameCount;//待写入的数据作为其大小
nsecs_t startTime = systemTime();
if (obtainBuffer(&mOutBuffer, waitTimeLeftMs) == (status_t)AudioTrack::NO_MORE_BUFFERS) {//调用obtainBuffer获取在mCblk后的空闲缓冲区，即mOutBuffer在其上有对应的内存缓冲区
LOGV (“OutputTrack::write() %p thread %p no more output buffers”, this, mThread.unsafe_get());
outputBufferFull = true;
break;//调用obtainBuffer失败，退出循环
}

uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() – startTime);
if (waitTimeLeftMs >= waitTimeMs) {
waitTimeLeftMs -= waitTimeMs;
} else {//若没有时间了，下次循环时退出
waitTimeLeftMs = 0;
}
}
uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : pInBuffer->frameCount;//取最小者，即可以写入这么多数据

memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channelCount * sizeof(int16_t));//将待写入的数据（队列上第一个节点或实参传递过来的数据）copy到mOutBuffer所对应的缓冲区（即mCblk后面的空闲缓冲区内存），完成写入过程

mCblk->stepUser(outFrames);//表示有outFrames写到mCblk后面的缓冲区mBuffer上，user计数向后迈进outFrames
pInBuffer->frameCount -= outFrames;//待写数据计数减少
pInBuffer->i16 += outFrames * channelCount;//指向下一个待写数据块
mOutBuffer.frameCount -= outFrames;//可能为0
mOutBuffer.i16 += outFrames * channelCount;//指针指向向前累加

if (pInBuffer->frameCount == 0) {//待写的数据都写完
if (mBufferQueue.size()) {
mBufferQueue.removeAt(0);//释放它
delete [] pInBuffer->mBuffer;
delete pInBuffer;
LOGV(“OutputTrack::write() %p thread %p released overflow buffer %d”, this, mThread.unsafe_get(), mBufferQueue.size());
} else {
break;
}
}
}

可见，第二部分代码是在线程允许的时间内，从mCblk后面的缓冲区mBuffer中获取一块空闲的输出内存（即调用obtainBuffer后得到的mOutBuffer），然后从缓冲队列mBufferQueue上取下第一项（若没有则直接是write要写的数据）取出一定数量的桢，copy到mOutBuffer中，也就是mCblk后面的缓冲区mBuffer中，相应地调整mCblk中的计数。

第三部分则是将write要写的数据（可能是剩下的部分地数据）放置到待写缓冲队列上：

// If we could not write all frames, allocate a buffer and queue it for next time.
if (inBuffer.frameCount) {//如果传递进来的还有待写的数据（可能是原封未动的数据，也可能是上面没有写完剩下的），则分配内存，然后将其copy到新分配的内存块上，再将其添加到待写队列上
sp<ThreadBase> thread = mThread.promote();
if (thread != 0 && !thread->standby()) {
if (mBufferQueue.size() < kMaxOverFlowBuffers) {
pInBuffer = new Buffer;
pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channelCount];//分配内存
pInBuffer->frameCount = inBuffer.frameCount;
pInBuffer->i16 = pInBuffer->mBuffer;
memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channelCount * sizeof(int16_t));//copy到新分配的内存块上
mBufferQueue.add(pInBuffer);//添加到队列上，这样每次write要写的数据可能被添加到待写队列mBufferQueue上
LOGV(“OutputTrack::write() %p thread %p adding overflow buffer %d”, this, mThread.unsafe_get(), mBufferQueue.size());
} else {
LOGW(“OutputTrack::write() %p thread %p no more overflow buffers”, mThread.unsafe_get(), this);
}
}
}

第四部分则是当调用者无数据可写时的情况，即要写入的frames为0，分配缓冲区添加一个节点，准备有数据到达时可先送往待写缓冲队列：

// Calling write() with a 0 length buffer, means that no more data will be written: If no more buffers are pending, fill output track buffer to make sure it is started by output mixer.
if (frames == 0 && mBufferQueue.size() == 0) {//无数据要写入，待写缓冲队列也为空
if (mCblk->user < mCblk->frameCount) {//有缓冲区空间，则将它们作为一块内存缓冲区添加到队列上
frames = mCblk->frameCount – mCblk->user;
pInBuffer = new Buffer;
pInBuffer->mBuffer = new int16_t[frames * channelCount];
pInBuffer->frameCount = frames;
pInBuffer->i16 = pInBuffer->mBuffer;
memset(pInBuffer->raw, 0, frames * channelCount * sizeof(int16_t));
mBufferQueue.add(pInBuffer);
} else if (mActive) {
stop();
}
}
return outputBufferFull;
}

 

线程相关类概述

线程类从Thread继承过来，ThreadBase和PlaybackThread都因为有纯虚函数，所以都是抽象类。在系统中真正运行的线程实体主要是MixerThread类的对象，DuplicatingThread用于复制输出，DirectOutputThread用于将声音直接送往HAL音频硬件，不经过混音处理。下图是其类继承关系图：

 

ThreadBase

ThreadBase类继承自Thread类，在其里面，嵌套定义了ConfigEvent（包含了Event类型和一个整型参数）用于通知audio配置信息的变化：当有配置信息变化时，调用ThreadBase的sendConfigEvent可以将某个ConfigEvent发送到队列上，然后在某个线程循环里调用ThreadBase的processConfigEvents来处理这些event事件。处理这些事件的过程如下：调用AudioFlinger的audioConfigChanged_l将配置事件通知到客户端，AudioFlinger是通过IAudioFlingerClient接口跨进程调用到应用程序侧的AudioFlingerClient类，见AudioSystem.cpp文件中的AudioSystem::AudioFlingerClient::ioConfigChanged函数（该函数也仅仅是缓存audio的配置信息）。通过IAudioFlingerClient接口跨进程调用的类继承关系图如下：

 

其中BpAudioFlingerClient运行在mediaserver进程中的AudioFlinger这个service中，嵌套类AudioFlingerClient运行在应用程序进程中。

 

PlaybackThread

CreateTrack_l

addTrack_l

 

 

MixerThread

对于MixerThread线程，有三样东西不得不提：一是其成员变量mAudioMixer，它是一个AudioMixer类的对象，在创建MixerThread对象时随其构造函数一起创建，线程中的所有活动的PCM音轨数据都是由它来进行混音的；二是线程函数threadLoop，它是线程的执行内容，在未要求退出的情况下，由它调度来实现声音的混合；三是成员函数prepareTracks_l，它为AudioMixer准备需要混合的音轨（track）及其它所需信息，以便在threadLoop中进行混合，还将非活动的音轨从活动列表中删除。

由于代码很多，也牵涉到很多音频处理方面的细节，这儿只摘录部分代码来分析其主体执行流程。在线程函数threadLoop的while循环中，调用了prepareTracks_l准备音轨之后，调用了AudioMixer的process进行混音处理，最后将这些混过音和经过音效处理后的数据写到HAL（硬件适配层）中的音频硬件中，实现声音的输出：

//…省略了代码

mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);//准备音轨信息，为混音做准备

// prevent any changes in effect chain list and in each effect //chain during mixing and effect process as the audio buffers could //be deleted or modified if an effect is created or deleted
lockEffectChains_l(effectChains);
}
if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
// mix buffers…
mAudioMixer->process();//混音处理
sleepTime = 0;
standbyTime = systemTime() + kStandbyTimeInNsecs;
//TODO: delay standby when effects have a tail
} else

//…省略了代码
if (sleepTime == 0) {
for (size_t i = 0; i < effectChains.size(); i ++) {
effectChains[i]->process_l();//音效处理
}
//…省略了代码

int bytesWritten = (int)mOutput->write(mMixBuffer, mixBufferSize);//写入HAL音频硬件

//…省略了代码

混音处理，是在AudioMixer中进行的，它将根据不同的情况调用AudioMixer【注释：下面这段描述得到了ZJY的帮助】：

process__genericNoResampling：多于2路Track的处理，不重采样

process__genericResampling：多于2路Track的处理，重采样

process__OneTrack16BitsStereoNoResampling：处理一路Track的情况，多数都是这种情况，只进行音量的调整处理。

process__TwoTracks16BitsStereoNoResampling：将两路声音处理为一路，处理完数据存放在MAIN_BUFFER中，亦即播放线程中的mMixerBuffer中（若有音效链则是音效链的inBuffer）。它不进行重采样。它使用累计乘法器将两路混合为一路。

 

再来看下prepareTracks_l，只摘录出设置缓冲区这块代码：

mAudioMixer->setParameter(
AudioMixer::TRACK, AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());//也就是将mMainBuffer设置过去，其实也就是播放线程中的mMixBuffer

mAudioMixer->setParameter(
AudioMixer::TRACK,
AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());//也就是Aux Effect的输入缓冲区

 

DuplicatingThread

成员函数updateWaitTime：因为声音都是按一定的采样率编码的，所以在播放时，也应该按其采样率去复现原声音，也就是说按一定频率将数据写入音频硬件。该函数就是检查线程中的各个track在写一次数据后该等待的时间，得最小者，赋值给成员变量mWaitTimeMs。

如果需要让声音同时在两个设备里输出，需要调用到AudioFlinger中的openDuplicateOutput打开复制输出。该函数根据两个输出设备号查找对应的mixer输出线程，然后创建一个DuplicatingThread复制线程，进而创建一个OutputTrack对象添加到主线程thread1中；接着再调用addOutputTrack创建一个OutputTrack对象，添加到线程thread2中：

int AudioFlinger::openDuplicateOutput(int output1, int output2)
{
Mutex::Autolock _l(mLock);
MixerThread *thread1 = checkMixerThread_l(output1);//得到对应的线程1
MixerThread *thread2 = checkMixerThread_l(output2);//得到对应的线程2
if (thread1 == NULL || thread2 == NULL) {
LOGW(“openDuplicateOutput() wrong output mixer type for output %d or %d”, output1, output2);
return 0;
}
int id = nextUniqueId();
DuplicatingThread *thread = new DuplicatingThread(this, thread1, id);//创建一个复制输出线程，当然也创建添加一个OutputTrack
thread->addOutputTrack(thread2);//为线程2添加一个OutputTrack
mPlaybackThreads.add(id, thread);//将自身（复制输出线程）添加到audioflinger中
// notify client processes of the new output creation
thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED);//通知配置改变
return id;
}

在DuplicatingThread的构造函数中，设置完线程为类型为DUPLICATING后，调用addOutputTrack创建一个OutputTrack（也就是将自己添加到mixer主线程的mTracks中），然后将其添加到DuplicatingThread自身的mOutputTracks列表中。

成员函数addOutputTrack用于创建一个OutputTrack对象，然后将其添加到DuplicatingThread自身的Tracks列表mOutputTracks中。在OutputTrack构造函数中，它会将自己添加到其第一个参数的线程中的Tracks列表中。也就是说，addOutputTrack会创建一个OutputTrack对象，将其添加到其参数指定的线程thread的Tracks列表中；同时，该OutputTrack对象也会被添加到DuplicatingThread自身的Tracks列表中。

void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
{
int frameCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate();
OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread, this, mSampleRate, mFormat, mChannelCount, frameCount);//在OutputTrack构造函数中，会将自己添加到其第一个参数（即mixer线程）维护的Tracks列表中
if (outputTrack->cblk() != NULL) {
thread->setStreamVolume(AudioSystem::NUM_STREAM_TYPES, 1.0f);
mOutputTracks.add(outputTrack);//添加到DuplicatingThread自身维护的列表中
LOGV(“addOutputTrack() track %p, on thread %p”, outputTrack, thread);
updateWaitTime();
}
}

再来看看DuplicatingThread的线程函数threadLoop，首先是准备好activeTracks，然后使用AudioMixer进行混音，再接着音效处理，最后就是将处理过的数据写入到OutputTrack对应的缓冲区。因为这Output也位于mixer线程的tracks列表中，所以它们最终在mixer线程中输出到HAL音频设备中。

其流程示意图如下，因为DuplicatingThread也继承自MixerThread，在threadLoop中如同MixerThread所要做的，首先将各活动音轨（activeTracks）进行混音和音效处理，然后将这些处理过的数据写入到OuputTrack中，而不是像MixerThread线程中写入到HAL音频硬件中。因为OuputTrack同时又位于个mixer输出线程的tracks中，所以它们由mixer线程输出到HAL硬件。

 

track1

ouput1

 

AudioMixer

 

track2

 

output2

 

DuplicatingThread

MixerThread

OutputTrack

AudioStreamOut

 

下面是threadLoop的主体代码：

mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);

//省略部分代码

if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
// mix buffers…
if (outputsReady(outputTracks)) {
mAudioMixer->process();//混音处理
} else {
memset(mMixBuffer, 0, mixBufferSize);
}
sleepTime = 0;
writeFrames = mFrameCount;
} else {

//省略部分代码

if (sleepTime == 0) {
for (size_t i = 0; i < effectChains.size(); i ++) {
effectChains[i]->process_l();//音效处理
}
// enable changes in effect chain
unlockEffectChains(effectChains);

//省略部分代码

for (size_t i = 0; i < outputTracks.size(); i++) {
outputTracks[i]->write(mMixBuffer, writeFrames);//将数据写入OutputTrack的缓冲队列或缓冲区
}

 

DirectOutputThread

 

下面的代码是其while循环内的代码，受上锁保护：

第一部分：检查配置是否变化

if (checkForNewParameters_l()) {

mixBufferSize = mFrameCount*mFrameSize;

activeSleepTime = activeSleepTimeUs();

idleSleepTime = idleSleepTimeUs();

standbyDelay = microseconds(activeSleepTime*2);

}

 

第二部分，无活动的track或需进入standby状态：

if UNLIKELY((!mActiveTracks.size() && systemTime() > standbyTime) || mSuspended) {//发生的可能性不大，UNLIKELY用于执行效率优化
// wait until we have something to do…
if (!mStandby) {//进入standby状态
LOGV(“Audio hardware entering standby, mixer %pn”, this);
mOutput->standby();
mStandby = true;
mBytesWritten = 0;
}

if (!mActiveTracks.size() && mConfigEvents.isEmpty()) {//无活动tracks，睡眠等待，直至被外界唤醒
// we’re about to wait, flush the binder command buffer
IPCThreadState::self()->flushCommands();
if (exitPending()) break;
LOGV(“DirectOutputThread %p TID %d going to sleepn”, this, gettid());
mWaitWorkCV.wait(mLock);
LOGV(“DirectOutputThread %p TID %d waking up in active moden”, this, gettid());
if (mMasterMute == false) {//检查设置静音
char value[PROPERTY_VALUE_MAX];
property_get(“ro.audio.silent”, value, “0″);
if (atoi(value)) {
LOGD(“Silence is golden”);
setMasterMute(true);
}
}
standbyTime = systemTime() + standbyDelay;
sleepTime = idleSleepTime;
continue;//继续循环
}
}

 

直接输出线程DirectOutputThread，不将音频数据送往AudioMixer送往混音器混音，而是直接输出到HAL音频硬件。线程循环函数threadLoop中，反映其主要执行流程的函数代码如下：

if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
AudioBufferProvider::Buffer buffer;
size_t frameCount = mFrameCount;
curBuf = (int8_t *)mMixBuffer;
// output audio to hardware
while (frameCount) {
buffer.frameCount = frameCount;
activeTrack->getNextBuffer(&buffer);//获取mCblk后面mBuffer中的数据已经ready的缓冲区
if (UNLIKELY(buffer.raw == 0)) {
memset(curBuf, 0, frameCount * mFrameSize);
break;
}
memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);//拷贝到mMixBuffer中
frameCount -= buffer.frameCount;
curBuf += buffer.frameCount * mFrameSize;
activeTrack->releaseBuffer(&buffer);//释放用过的缓冲区
}
sleepTime = 0;
standbyTime = systemTime() + standbyDelay;

}

它将mCblk后面的缓冲区中的数据copy到mMixBuffer后，再经（过下面的代码）音效链的音效处理后，直接输出到音频HAL音频硬件中（通过AudioStreamOut的write函数）：

if (sleepTime == 0) {
if (mixerStatus == MIXER_TRACKS_READY) {
applyVolume(leftVol, rightVol, rampVolume);
}
for (size_t i = 0; i < effectChains.size(); i ++) {
effectChains[i]->process_l();//调用音效链上的音效进行处理
}
unlockEffectChains(effectChains);
mLastWriteTime = systemTime();
mInWrite = true;
mBytesWritten += mixBufferSize;
int bytesWritten = (int)mOutput->write(mMixBuffer, mixBufferSize);//完成音频数据到HAL音频硬件的输出
if (bytesWritten < 0) mBytesWritten -= mixBufferSize;
mNumWrites++;
mInWrite = false;
mStandby = false;
} else {
unlockEffectChains(effectChains);
usleep(sleepTime);
}

 

若要复制输出，则使用函数openDuplicateOutput；若要直接输出，不进行混音，则在调用AudioFlinger::openOutput函数时，在其最后一个参数flags指定OUTPUT_FLAG_DIRECT标志。下面是部分代码摘录：

int AudioFlinger::openOutput(uint32_t *pDevices,
uint32_t *pSamplingRate,
uint32_t *pFormat,
uint32_t *pChannels,
uint32_t *pLatencyMs,
uint32_t flags)
{
…//省略部分代码
AudioStreamOut *output = mAudioHardware->openOutputStream(*pDevices, (int *)&format, &channels, &samplingRate,&status);//调用HAL音频硬件打开一个输出流
…//省略部分代码

if (output != 0) {
int id = nextUniqueId();
if ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) ||//直接输出标志
(format != AudioSystem::PCM_16_BIT) || //非16位
(channels != AudioSystem::CHANNEL_OUT_STEREO)) {//非立体声
thread = new DirectOutputThread(this, output, id, *pDevices);//在直接指定输出标志、非16位数据或非立体声输出时，创建直接输出线程
LOGV(“openOutput() created direct output: ID %d thread %p”, id, thread);
} else {
thread = new MixerThread(this, output, id, *pDevices);//创建混音线程进行混音输出
LOGV(“openOutput() created mixer output: ID %d thread %p”, id, thread);
…//省略部分代码

可见，在使用标志或一定的参数的情况去打开一个输出流时，Audioflinger创建对应的输出线程，要么是直接输出线程，要么是混音线程。此处也可同时看出，系统中运行的播放线程只有混音线程、直接输出线程和复制线程三个类的实例对象。