Android音频数据传输

MediaPlayer那边就不看了，从AudioTrack开始研究。

1、AudioTrack::write函数

调用函数obtainBuffer获取到一块buffer，然后把传入的数据copy到获取的buffer中。

2、AudioTrack::obtainBuffer函数

该函数的主要功能就是对传入的audioBuffer进行赋值。

看看audioBuffer的类型：

class Buffer

    {

    public:

        enum {

            MUTE    = 0x00000001

        };

        uint32_t    flags;

        int         channelCount;

        int         format;

        size_t      frameCount;

        size_t      size;

        union {

            void*       raw;

            short*      i16;

            int8_t*     i8;

        };

    };

其中存放数据的是下面这个东东：

union {

            void*       raw;

            short*      i16;

            int8_t*     i8;

        };

对这块东东赋值的代码如下：

audioBuffer->raw = (int8_t *)cblk->buffer(u);

先看其中cblk的来历：

audio_track_cblk_t* cblk = mCblk;

mCblk的赋值在函数AudioTrack::createTrack中：

mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer());

cblk的由来：

sp<IMemory> cblk = track->getCblk();

track的由来：

    sp<IAudioTrack> track = audioFlinger->createTrack(getpid(),

                                                      streamType,

                                                      sampleRate,

                                                      format,

                                                      channelCount,

                                                      frameCount,

                                                      ((uint16_t)flags) << 16,

                                                      sharedBuffer,

                                                      output,

                                                      &mSessionId,

                                                      &status);
 

函数AudioFlinger::createTrack返回的是一个TrackHandle对象：

trackHandle = new TrackHandle(track);

return trackHandle;

track的由来：

        track = thread->createTrack_l(client, streamType, sampleRate, format,

                channelCount, frameCount, sharedBuffer, lSessionId, &lStatus);

函数AudioFlinger::PlaybackThread::createTrack_l返回的是一个Track对象：

        track = new Track(this, client, streamType, sampleRate, format,

                channelCount, frameCount, sharedBuffer, sessionId);

    return track;

看看函数TrackHandle::getCblk() ：

return mTrack->getCblk();

mTrack就是作为构造函数传入的track对象。

函数AudioFlinger::ThreadBase::TrackBase::getCblk() 的实现：

return mCblkMemory;

mCblkMemory的赋值在构造函数AudioFlinger::ThreadBase::TrackBase::TrackBase中：

mCblkMemory = client->heap()->allocate(size);

mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer()); // 这个成员变量也很重要

client是构造函数参数：

const sp<Client>& client

函数AudioFlinger::Client::heap：

return mMemoryDealer;

mMemoryDealer的赋值在函数AudioFlinger::Client::Client中：

mMemoryDealer(new MemoryDealer(1024*1024, "AudioFlinger::Client"))

看看函数MemoryDealer::allocate：

sp<IMemory> MemoryDealer::allocate(size_t size)

{

    sp<IMemory> memory;
// allocator()直接返回mAllocator
// mAllocator的赋值在构造函数中：mAllocator(new SimpleBestFitAllocator(size))
/× 函数SimpleBestFitAllocator::allocate的实现：
size_t SimpleBestFitAllocator::allocate(size_t size, uint32_t flags)
{
Mutex::Autolock _l(mLock);
// 暂止
ssize_t offset = alloc(size, flags);
return offset;
}
×/

    const ssize_t offset = allocator()->allocate(size);

    if (offset >= 0) {
// heap()直接返回mHeap
// mHeap的赋值在构造函数中：mHeap(new MemoryHeapBase(size, 0, name))

        memory = new Allocation(this, heap(), offset, size);

    }

    return memory;

}

可见前面的mCblkMemory其实就是一个Allocation对象。

可见AudioTrack的成员变量mCblk和AudioFlinger::ThreadBase::TrackBase的成员变量mCblk的值相同，

都是：static_cast<audio_track_cblk_t *>(mCblkMemory->pointer())。

函数IMemory::pointer的实现：

void* IMemory::pointer() const {

    ssize_t offset;

    sp<IMemoryHeap> heap = getMemory(&offset);

    void* const base = heap!=0 ? heap->base() : MAP_FAILED;

    if (base == MAP_FAILED)

        return 0;

    return static_cast<char*>(base) + offset;

}

回头过去，看看函数audio_track_cblk_t::buffer：

return (int8_t *)this->buffers + (offset - userBase) * this->frameSize;

可见audio_track_cblk_t的主要作用是申请了一块内存空间。

调用函数AudioTrack::write的时候，会先将数据写到这个内存空间中。

3、数据写入到了audio_track_cblk_t中，谁又会来使用这些数据呢？

看代码可知，函数AudioTrack::obtainBuffer中会先调用audio_track_cblk_t::framesAvailable。

同时，我们发现还有一个函数audio_track_cblk_t::framesReady。

单从字面上也可以看出来，这是告诉用户准备好了多少数据。

搜搜哪儿调用了函数audio_track_cblk_t::framesReady吧。

搜了下，发现有三个函数中调用了它，分别是：

AudioFlinger::MixerThread::prepareTracks_l函数

AudioFlinger::DirectOutputThread::threadLoop函数

AudioFlinger::PlaybackThread::Track::getNextBuffer函数

4、先看看函数AudioFlinger::MixerThread::prepareTracks_l函数。

字面上看，应该是准备提供数据的Tracks。

果然不错，函数中调用AudioMixer::setBufferProvider将Track设置到mAudioMixer（AudioMixer）中。

函数AudioMixer::setBufferProvider实现：

status_t AudioMixer::setBufferProvider(AudioBufferProvider* buffer)

{

    mState.tracks[ mActiveTrack ].bufferProvider = buffer;

    return NO_ERROR;

}

然后调用函数AudioMixer::setParameter将Track的main buffer也设置到mAudioMixer（AudioMixer）中。

函数AudioMixer::setParameter中与main buffer相关的部分代码：

        if (name == MAIN_BUFFER) {

            if (mState.tracks[ mActiveTrack ].mainBuffer != valueBuf) {

                mState.tracks[ mActiveTrack ].mainBuffer = valueBuf;

                LOGV("setParameter(TRACK, MAIN_BUFFER, %p)", valueBuf);

                invalidateState(1<<mActiveTrack);

            }

            return NO_ERROR;

        }

类函数AudioMixer中是如何来使用bufferProvider的呢？

AudioMixer中的以process__为前缀的几个函数都是有到了bufferProvider。

但从数据传输上来说，这几个函数是类似的。

我们只看其中的AudioMixer::process__OneTrack16BitsStereoNoResampling函数。

函数中有代码：

t.bufferProvider->getNextBuffer(&b);

我们知道，bufferProvider其实就是Track，而我们探讨的是音频播放，所以就跳到了函数：AudioFlinger::PlaybackThread::Track::getNextBuffer，

也就是前面我们搜到的，调用audio_track_cblk_t::framesReady的三个函数之一。

函数AudioFlinger::PlaybackThread::Track::getNextBuffer是从audio_track_cblk_t中取得已准备好的音频数据，

写到什么地方去，下面我们开始研究。

回到函数process__OneTrack16BitsStereoNoResampling中，我们知道，调用AudioFlinger::PlaybackThread::Track::getNextBuffer获取的地址赋值给了in：

int16_t const *in = b.i16;

后来取in的数据给了rl：

uint32_t rl = *reinterpret_cast<uint32_t const *>(in);

然后将rl赋值给out：

*out++ = (r<<16) | (l & 0xFFFF);

由此可见，我们刚才疑惑的“写到什么地方去”，其实就是写到out里了。

out的来历：

int32_t* out = t.mainBuffer;

这不就是函数AudioMixer::setParameter中赋值的main buffer么？？？

搞了一圈，原来AudioMixer的功能就是将Track里audio_track_cblk_t中的数据，赋值给Track里的mainBuffer。

下面好好看看这个main buffer的来历吧。

由前面的分析可知，调用函数AudioMixer::setParameter，来设置main buffer的地方是函数AudioFlinger::MixerThread::prepareTracks_l。

回过去看看对函数AudioMixer::setParameter的调用：

            mAudioMixer->setParameter(

                AudioMixer::TRACK,

                AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());

函数mainBuffer()实现：

 return mMainBuffer; 

 

 mMainBuffer的赋值在函数setMainBuffer中：

 setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; }

 

 看看谁调用了函数setMainBuffer吧。

 

 有三个地方调用了函数setMainBuffer：

 a、AudioFlinger::PlaybackThread::createTrack_l函数

 b、AudioFlinger::PlaybackThread::addEffectChain_l函数

 c、AudioFlinger::PlaybackThread::removeEffectChain_l函数

 

 b和c类似，都是将PlaybackThread的mMixBuffer赋值给了main buffer。

 

 先看看a.

 track->setMainBuffer(chain->inBuffer());

 作为main buffer的是chain->inBuffer()这个东东。

 

 inBuffer()函数实现：return mInBuffer;

 mInBuffer中函数setInBuffer中被赋值：

 mInBuffer = buffer;

 

 看看调用setInBuffer函数的地方：

 AudioFlinger::PlaybackThread::addEffectChain_l函数

 AudioFlinger::EffectChain::addEffect_l函数

 

 先看看AudioFlinger::PlaybackThread::addEffectChain_l函数中的处理，

 函数中根据是否为DIRECT output thread，有两种处理方式：

 一种是处理direct output thread:
调用函数setMainBuffer将PlaybackThread的mMixBuffer告诉给Track，即告诉Track，在AudioMixer中往PlaybackThread的mMixBuffer中copy数据。
然后将effect  chain的input buffer和output buffer都设置为PlaybackThread的mMixBuffer。
（目的是让该effect chain不起作用？存在注释“Only one effect chain can be present in direct output thread and it usesthe mix buffer as input”）

另一种是处理非direct output thread:
new一段buffer出来。
调用函数setMainBuffer将新buffer告诉给Track，即告诉Track，在AudioMixer中往新buffer中copy数据。
调用函数setInBuffer来实装chain的input buffer。（发现函数AudioFlinger::PlaybackThread::createTrack_l中其实有将chain的input buffer赋值给Track的main buffer）。
然后将PlaybackThread的mMixBuffer赋值给chain的output buffer。
也就是说，Track将数据copy到自己的main buffer(即effect chain的input buffer)，
effect chain对数据进行处理，然后将处理过的数据赋值给自己的output buffer(即PlaybackThread的mMixBuffer)

mMixBuffer是如何被使用的呢？

函数AudioFlinger::MixerThread::threadLoop中调用函数AudioStreamOutALSA::write（HAL侧）。

函数AudioStreamOutALSA::write中调用了函数snd_pcm_mmap_writei或者snd_pcm_writei。

函数snd_pcm_mmap_writei或者snd_pcm_writei将mMixBuffer中的数据写入到底层。