1、背景
在學習audio的過程中，看到了大神zyuanyun的博客，在博客的結尾，大神留下了這些問題：
但是大神沒有出后續的博文來說明audio環形緩沖隊列的具體實現，這勾起了我強烈的好奇心。經過一段時間的走讀代碼，同時閱讀其他大佬的博文，把環形緩沖隊列的內容整理出來。
2、AudioPolicyService、AudioFlinger及相關類
AudioPolicyService，簡稱APS，是負責音頻策略的制定者：比如什么時候打開音頻接口設備、某種Stream類型的音頻對應什么設備等等；AudioFlinger，簡稱AF，負責音頻策略的具體執行，比如：如何與音頻設備通信，如何維護現有系統中的音頻設備，以及多個音頻流的混音如何處理等。
環形緩沖隊列大致可以以下面這幅圖來描述其流程：
3、Track的創建
AudioTrack的創建經過漫長的調用鏈，最終是/frameworks/av/services/audioflinger/Tracks.cpp里完成創建的。
// TrackBase constructor must be called with AudioFlinger::mLock held
AudioFlinger::ThreadBase::TrackBase::TrackBase(){//計算最小幀大小size_t minBufferSize = buffer == NULL ? roundup(frameCount) : frameCount;……minBufferSize *= mFrameSize;size_t size = sizeof(audio_track_cblk_t);if (buffer == NULL && alloc == ALLOC_CBLK) {// check overflow when computing allocation size for streaming tracks.if (size > SIZE_MAX - bufferSize) {android_errorWriteLog(0x534e4554, "34749571");return;}size += bufferSize;}if (client != 0) {//為客戶端分配內存mCblkMemory = client->heap()->allocate(size);……} else {mCblk = (audio_track_cblk_t *) malloc(size);……}// construct the shared structure in-place.if (mCblk != NULL) {// 這是 C++ 的 placement new（定位創建對象）語法：new(@BUFFER) @CLASS();// 可以在特定內存位置上構造一個對象// 這里，在匿名共享內存首地址上構造了一個 audio_track_cblk_t 對象// 這樣 AudioTrack 與 AudioFlinger 都能訪問這個 audio_track_cblk_t 對象了new(mCblk) audio_track_cblk_t();switch (alloc) {……case ALLOC_CBLK:// clear all buffersif (buffer == NULL) {// 數據 FIFO 的首地址緊靠控制塊（audio_track_cblk_t）之后// | |// | -------------------> mCblkMemory <--------------------- |// | |// +--------------------+------------------------------------+// | audio_track_cblk_t | Buffer |// +--------------------+------------------------------------+// ^ ^// | |// mCblk mBuffer//這里mCblk被強制轉型成占用內存1字節的char類型，這個"1"在后面會用到mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);memset(mBuffer, 0, bufferSize);} else {// 數據傳輸模式為 MODE_STATIC/TRANSFER_SHARED 時，直接指向 sharedBuffer// sharedBuffer 是應用進程分配的匿名共享內存，應用進程已經一次性把數據// 寫到 sharedBuffer 來了，AudioFlinger 可以直接從這里讀取// +--------------------+ +-----------------------------------+// | audio_track_cblk_t | | sharedBuffer |// +--------------------+ +-----------------------------------+// ^ ^// | |// mCblk mBuffermBuffer = buffer;}break;……}……}
}
4、生產者向共享內存寫入數據
4.1
4.2 向共享內存寫入數據
//framework/av/media/libaudioclient/AudioTrack.cpp
ssize_t AudioTrack::write(const void* buffer, size_t userSize, bool blocking)
{……size_t written = 0;Buffer audioBuffer;while (userSize >= mFrameSize) {// 單幀數據量 frameSize = channelCount * bytesPerSample// 對于雙聲道，16位采樣的音頻數據來說，frameSize = 2 * 2 = 4(bytes)// 用戶傳入的數據幀數 frameCount = userSize / frameSizeaudioBuffer.frameCount = userSize / mFrameSize;// obtainBuffer() 從 FIFO 上得到一塊可用區間status_t err = obtainBuffer(&audioBuffer,blocking ? &ClientProxy::kForever : &ClientProxy::kNonBlocking);……size_t toWrite = audioBuffer.size;memcpy(audioBuffer.i8, buffer, toWrite);buffer = ((const char *) buffer) + toWrite;userSize -= toWrite;written += toWrite;releaseBuffer(&audioBuffer);}……return written;
}status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, const struct timespec *requested,struct timespec *elapsed, size_t *nonContig)
{// previous and new IAudioTrack sequence numbers are used to detect track re-creationuint32_t oldSequence = 0;uint32_t newSequence;Proxy::Buffer buffer;status_t status = NO_ERROR;static const int32_t kMaxTries = 5;int32_t tryCounter = kMaxTries;do {// obtainBuffer() is called with mutex unlocked, so keep extra references to these fields to// keep them from going away if another thread re-creates the track during obtainBuffer()sp<AudioTrackClientProxy> proxy;sp<IMemory> iMem;{ // start of lock scopeAutoMutex lock(mLock);……// Keep the extra referencesproxy = mProxy;iMem = mCblkMemory;……} // end of lock scopebuffer.mFrameCount = audioBuffer->frameCount;// FIXME starts the requested timeout and elapsed over from scratchstatus = proxy->obtainBuffer(&buffer, requested, elapsed);} while (((status == DEAD_OBJECT) || (status == NOT_ENOUGH_DATA)) && (tryCounter-- > 0));audioBuffer->frameCount = buffer.mFrameCount;audioBuffer->size = buffer.mFrameCount * mFrameSize;audioBuffer->raw = buffer.mRaw;if (nonContig != NULL) {*nonContig = buffer.mNonContig;}return status;
}
//framework/av/media/libaudioclient/AudioTrackShared.cpp
__attribute__((no_sanitize("integer")))
status_t ClientProxy::obtainBuffer(Buffer* buffer, const struct timespec *requested,struct timespec *elapsed)
{……struct timespec before;bool beforeIsValid = false;audio_track_cblk_t* cblk = mCblk;bool ignoreInitialPendingInterrupt = true;for (;;) {int32_t flags = android_atomic_and(~CBLK_INTERRUPT, &cblk->mFlags);……int32_t front;int32_t rear;if (mIsOut) {front = android_atomic_acquire_load(&cblk->u.mStreaming.mFront);rear = cblk->u.mStreaming.mRear;} else {// On the other hand, this barrier is required.rear = android_atomic_acquire_load(&cblk->u.mStreaming.mRear);front = cblk->u.mStreaming.mFront;}// write to rear, read from frontssize_t filled = audio_utils::safe_sub_overflow(rear, front);……ssize_t adjustableSize = (ssize_t) getBufferSizeInFrames();ssize_t avail = (mIsOut) ? adjustableSize - filled : filled;if (avail < 0) {avail = 0;} else if (avail > 0) {// 'avail' may be non-contiguous, so return only the first contiguous chunksize_t part1;if (mIsOut) {rear &= mFrameCountP2 - 1;part1 = mFrameCountP2 - rear;} else {front &= mFrameCountP2 - 1;part1 = mFrameCountP2 - front;}if (part1 > (size_t)avail) {part1 = avail;}if (part1 > buffer->mFrameCount) {part1 = buffer->mFrameCount;}buffer->mFrameCount = part1;buffer->mRaw = part1 > 0 ?&((char *) mBuffers)[(mIsOut ? rear : front) * mFrameSize] : NULL;buffer->mNonContig = avail - part1;mUnreleased = part1;status = NO_ERROR;break;}struct timespec remaining;const struct timespec *ts;……int32_t old = android_atomic_and(~CBLK_FUTEX_WAKE, &cblk->mFutex);if (!(old & CBLK_FUTEX_WAKE)) {……errno = 0;(void) syscall(__NR_futex, &cblk->mFutex,mClientInServer ? FUTEX_WAIT_PRIVATE : FUTEX_WAIT, old & ~CBLK_FUTEX_WAKE, ts);……}}end:……return status;
}void ClientProxy::releaseBuffer(Buffer* buffer)
{size_t stepCount = buffer->mFrameCount;……mUnreleased -= stepCount;audio_track_cblk_t* cblk = mCblk;// Both of these barriers are requiredif (mIsOut) {int32_t rear = cblk->u.mStreaming.mRear;android_atomic_release_store(stepCount + rear, &cblk->u.mStreaming.mRear);} else {int32_t front = cblk->u.mStreaming.mFront;android_atomic_release_store(stepCount + front, &cblk->u.mStreaming.mFront);}
}
4、消費者從共享內存讀數據
找到當前活動的track需要經過很長的準備及調用鏈，可以參考這篇博客。
4.1 PlaybackThread的混音
代碼路徑：frameworks/av/services/audioflinger/Threads.cpp
void AudioFlinger::MixerThread::threadLoop_mix()
{// mix buffers...mAudioMixer->process();mCurrentWriteLength = mSinkBufferSize;……
}
process()方法之后進入track的混音流程，代碼位于frameworks/av/media/libaudioprocessing/AudioMixer.cpp。來看process()的定義：
using process_hook_t = void(AudioMixer::*)();process_hook_t mHook = &AudioMixer::process__nop; void invalidate() {mHook = &AudioMixer::process__validate;}void process__validate();void process__nop();void process__genericNoResampling();void process__genericResampling();void process__oneTrack16BitsStereoNoResampling();template <int MIXTYPE, typename TO, typename TI, typename TA>void process__noResampleOneTrack();hook是一個函數指針，根據不同場景會分別指向不同函數實現。詳細可以參考這篇博客，以及這篇博客。以process__nop方法為例：
void AudioMixer::process__nop()
{for (const auto &pair : mGroups) {const auto &group = pair.second;const std::shared_ptr<Track> &t = mTracks[group[0]];memset(t->mainBuffer, 0,mFrameCount * audio_bytes_per_frame(t->mMixerChannelCount + t->mMixerHapticChannelCount, t->mMixerFormat));// now consume datafor (const int name : group) {const std::shared_ptr<Track> &t = mTracks[name];size_t outFrames = mFrameCount;while (outFrames) {t->buffer.frameCount = outFrames;t->bufferProvider->getNextBuffer(&t->buffer);if (t->buffer.raw == NULL) break;outFrames -= t->buffer.frameCount;t->bufferProvider->releaseBuffer(&t->buffer);}}}
}
frameworks/av/services/audioflinger/Tracks.cpp
status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
{ServerProxy::Buffer buf;size_t desiredFrames = buffer->frameCount;buf.mFrameCount = desiredFrames;status_t status = mServerProxy->obtainBuffer(&buf);buffer->frameCount = buf.mFrameCount;buffer->raw = buf.mRaw;if (buf.mFrameCount == 0 && !isStopping() && !isStopped() && !isPaused()) {mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);} else {mAudioTrackServerProxy->tallyUnderrunFrames(0);}return status;
}void AudioFlinger::PlaybackThread::Track::releaseBuffer(AudioBufferProvider::Buffer* buffer)
{interceptBuffer(*buffer);TrackBase::releaseBuffer(buffer);
}
/frameworks/av/media/libaudioclient/AudioTrackShared.cpp
status_t ServerProxy::obtainBuffer(Buffer* buffer, bool ackFlush)
{{audio_track_cblk_t* cblk = mCblk;// compute number of frames available to write (AudioTrack) or read (AudioRecord),// or use previous cached value from framesReady(), with added barrier if it omits.int32_t front;int32_t rear;// See notes on barriers at ClientProxy::obtainBuffer()if (mIsOut) {flushBufferIfNeeded(); // might modify mFrontrear = getRear();front = cblk->u.mStreaming.mFront;} else {front = android_atomic_acquire_load(&cblk->u.mStreaming.mFront);rear = cblk->u.mStreaming.mRear;}……// 'availToServer' may be non-contiguous, so return only the first contiguous chunksize_t part1;if (mIsOut) {front &= mFrameCountP2 - 1;part1 = mFrameCountP2 - front;} else {rear &= mFrameCountP2 - 1;part1 = mFrameCountP2 - rear;}if (part1 > availToServer) {part1 = availToServer;}size_t ask = buffer->mFrameCount;……
}int32_t AudioTrackServerProxy::getRear() const
{const int32_t stop = android_atomic_acquire_load(&mCblk->u.mStreaming.mStop);const int32_t rear = android_atomic_acquire_load(&mCblk->u.mStreaming.mRear);const int32_t stopLast = mStopLast.load(std::memory_order_acquire);……return rear;
}
5、總結
經過一段時間的代碼走讀，能夠回答文章開頭提出的部分問題，但是諸如“讀寫指針線程安全”、“Futex同步機制”等問題現階段還回答不上來，以后有機會再深入研究下。
