看到的一篇比较好的AudioFlinger分析（2）

    到底执行哪个线程的threadLoop？我记得我们是根据output句柄来查找线程的。
看看openOutput的实行，真正的线程对象创建是在那儿。
nt AudioFlinger::openOutput(uint32_t *pDevices,
                                uint32_t *pSamplingRate,
                                uint32_t *pFormat,
                                uint32_t *pChannels,
                                uint32_t *pLatencyMs,
                                uint32_t flags)
{
        if ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) ||
            (format != AudioSystem::PCM_16_BIT) ||
            (channels != AudioSystem::CHANNEL_OUT_STEREO)) {
            thread = new DirectOutputThread(this, output, ++mNextThreadId);
//如果flags没有设置直接输出标准，或者format不是16bit，或者声道数不是2立体声
//则创建DirectOutputThread。       
} else {
    //可惜啊，我们创建的是最复杂的MixerThread  
 thread = new MixerThread(this, output, ++mNextThreadId);   
1. MixerThread
非常重要的工作线程，我们看看它的构造函数。
AudioFlinger::MixerThread::MixerThread(const sp& audioFlinger, AudioStreamOut* output, int id)
    :   PlaybackThread(audioFlinger, output, id),
        mAudioMixer(0)
{
mType = PlaybackThread::MIXER;
//混音器对象，传进去的两个参数时基类ThreadBase的，都为0
//这个对象巨复杂，最终混音的数据都由它生成，以后再说...
    mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);
   }
2. AT调用start
此时，AT得到IAudioTrack对象后，调用start函数。
status_t AudioFlinger::TrackHandle::start() {
    return mTrack->start();
} //果然，自己又不干活，交给mTrack了，这个是PlayintThread createTrack_l得到的Track对象
status_t AudioFlinger::PlaybackThread::Track::start()
{
    status_t status = NO_ERROR;
sp thread = mThread.promote();
//这个Thread就是调用createTrack_l的那个thread对象，这里是MixerThread
    if (thread != 0) {
        Mutex::Autolock _l(thread->mLock);
        int state = mState;
         if (mState == PAUSED) {
            mState = TrackBase::RESUMING;
           } else {
            mState = TrackBase::ACTIVE;
        }
  //把自己由加到addTrack_l了
//奇怪，我们之前在看createTrack_l的时候，不是已经有个map保存创建的track了
//这里怎么又出现了一个类似的操作？
        PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
        playbackThread->addTrack_l(this);
    return status;
}
看看这个addTrack_l函数
status_t AudioFlinger::PlaybackThread::addTrack_l(const sp& track)
{
    status_t status = ALREADY_EXISTS;
    // set retry count for buffer fill
    track->mRetryCount = kMaxTrackStartupRetries;
    if (mActiveTracks.indexOf(track) < 0) {
        mActiveTracks.add(track);//啊，原来是加入到活跃Track的数组啊
        status = NO_ERROR;
}
//我靠，有戏啊！看到这个broadcast，一定要想到：恩，在不远处有那么一个线程正
//等着这个CV呢。
    mWaitWorkCV.broadcast();
   return status;
}
让我们想想吧。start是把某个track加入到PlayingThread的活跃Track队列，然后触发一个信号事件。由于这个事件是PlayingThread的内部成员变量，而PlayingThread又创建了一个线程，那么难道是那个线程在等待这个事件吗？这时候有一个活跃track，那个线程应该可以干活了吧？
这个线程是MixerThread。我们去看看它的线程函数threadLoop吧。
bool AudioFlinger::MixerThread::threadLoop()
{
    int16_t* curBuf = mMixBuffer;
    Vector< sp > tracksToRemove;
 while (!exitPending())
    {
        processConfigEvents();
//Mixer进到这个循环中来
        mixerStatus = MIXER_IDLE;
        { // scope for mLock
           Mutex::Autolock _l(mLock);
            const SortedVector< wp >& activeTracks = mActiveTracks;
//每次都取当前最新的活跃Track数组
//下面是预备操作，返回状态看看是否有数据需要获取
mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);
       }
//LIKELY，是GCC的一个东西，可以优化编译后的代码
//就当做是TRUE吧
if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
            // mix buffers...
//调用混音器，把buf传进去，估计得到了混音后的数据了
//curBuf是mMixBuffer，PlayingThread的内部buffer，在某个地方已经创建好了，
//缓存足够大
            mAudioMixer->process(curBuf);
            sleepTime = 0;
            standbyTime = systemTime() + kStandbyTimeInNsecs;
        }
有数据要写到硬件中，肯定不能sleep了呀
if (sleepTime == 0) {
           //把缓存的数据写到outPut中。这个mOutput是AudioStreamOut
//由Audio HAL的那个对象创建得到。等我们以后分析再说
           int bytesWritten = (int)mOutput->write(curBuf, mixBufferSize);
            mStandby = false;
        } else {
            usleep(sleepTime);//如果没有数据，那就休息吧..
        }
3. MixerThread核心
到这里，大家是不是有种焕然一新的感觉？恩，对了，AF的工作就是如此的精密，每个部分都配合得丝丝入扣。不过对于我们看代码的人来说，实在搞不懂这么做的好处----哈哈  有点扯远了。
MixerThread的线程循环中，最重要的两个函数：
prepare_l和mAudioMixer->process，我们一一来看看。
uint32_t AudioFlinger::MixerThread::prepareTracks_l(const SortedVector< wp >& activeTracks, Vector< sp > *tracksToRemove)
{
    uint32_t mixerStatus = MIXER_IDLE;
    //得到活跃track个数，这里假设就是我们创建的那个AT吧，那么count=1
    size_t count = activeTracks.size();
    float masterVolume = mMasterVolume;
    bool  masterMute = mMasterMute;
   for (size_t i=0 ; i        sp t = activeTracks[i].promote();
      Track* const track = t.get()；
   //得到placement new分配的那个跨进程共享的对象
        audio_track_cblk_t* cblk = track->cblk();
//设置混音器，当前活跃的track。
        mAudioMixer->setActiveTrack(track->name());
        if (cblk->framesReady() && (track->isReady() || track->isStopped()) &&
                !track->isPaused() && !track->isTerminated())
        {
            // compute volume for this track
//AT已经write数据了。所以肯定会进到这来。
            int16_t left, right;
            if (track->isMuted() || masterMute || track->isPausing() ||
                mStreamTypes[track->type()].mute) {
                left = right = 0;
                if (track->isPausing()) {
                    track->setPaused();
                }
//AT设置的音量假设不为零，我们需要聆听声音！
//所以走else流程
            } else {
                // read original volumes with volume control
                float typeVolume = mStreamTypes[track->type()].volume;
                float v = masterVolume * typeVolume;
                float v_clamped = v * cblk->volume[0];
                if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
                left = int16_t(v_clamped);
                v_clamped = v * cblk->volume[1];
                if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
                right = int16_t(v_clamped);
//计算音量
            }
//注意，这里对混音器设置了数据提供来源，是一个track，还记得我们前面说的吗？Track从
AudioBufferProvider派生
          mAudioMixer->setBufferProvider(track);
            mAudioMixer->enable(AudioMixer::MIXING);
            int param = AudioMixer::VOLUME;
           //为这个track设置左右音量等
          mAudioMixer->setParameter(param, AudioMixer::VOLUME0, left);
            mAudioMixer->setParameter(param, AudioMixer::VOLUME1, right);
            mAudioMixer->setParameter(
                AudioMixer::TRACK,
                AudioMixer::FORMAT, track->format());
            mAudioMixer->setParameter(
                AudioMixer::TRACK,
                AudioMixer::CHANNEL_COUNT, track->channelCount());
            mAudioMixer->setParameter(
                AudioMixer::RESAMPLE,
                AudioMixer::SAMPLE_RATE,
                int(cblk->sampleRate));
        } else {
           if (track->isStopped()) {
                track->reset();
            }
  //如果这个track已经停止了，那么把它加到需要移除的track队列tracksToRemove中去
//同时停止它在AudioMixer中的混音
            if (track->isTerminated() || track->isStopped() || track->isPaused()) {
                tracksToRemove->add(track);
                mAudioMixer->disable(AudioMixer::MIXING);
            } else {
                mAudioMixer->disable(AudioMixer::MIXING);
            }
        }
    }
    // remove all the tracks that need to be...
    count = tracksToRemove->size();
    return mixerStatus;
}
看明白了吗？prepare_l的功能是什么？根据当前活跃的track队列，来为混音器设置信息。可想而知，一个track必然在混音器中有一个对应的东西。我们待会分析AudioMixer的时候再详述。
为混音器准备好后，下面调用它的process函数
void AudioMixer::process(void* output)
{
    mState.hook(&mState, output);//hook？难道是钩子函数？
}
晕乎，就这么简单的函数？？？
CTRL+左键，hook是一个函数指针啊，在哪里赋值的？具体实现函数又是哪个？
没办法了，只能分析AudioMixer类了。
4. AudioMixer
AudioMixer实现在framework/base/libs/audioflinger/AudioMixer.cpp中
AudioMixer::AudioMixer(size_t frameCount, uint32_t sampleRate)
    :   mActiveTrack(0), mTrackNames(0), mSampleRate(sampleRate)
{
    mState.enabledTracks= 0;
    mState.needsChanged = 0;
    mState.frameCount   = frameCount;
    mState.outputTemp   = 0;
    mState.resampleTemp = 0;
    mState.hook         = process__nop;//process__nop，是该类的静态函数
track_t* t = mState.tracks;
//支持32路混音。牛死了
    for (int i=0 ; i<32 ; i++) {
        t->needs = 0;
        t->volume[0] = UNITY_GAIN;
        t->volume[1] = UNITY_GAIN;
        t->volumeInc[0] = 0;
        t->volumeInc[1] = 0;
        t->channelCount = 2;
        t->enabled = 0;
        t->format = 16;
        t->buffer.raw = 0;
        t->bufferProvider = 0;
        t->hook = 0;
        t->resampler = 0;
        t->sampleRate = mSampleRate;
        t->in = 0;
        t++;
    }
}
//其中，mState是在AudioMixer.h中定义的一个数据结构
//注意，source insight没办法解析这个mState，因为....见下面的注释。
struct state_t {
        uint32_t        enabledTracks;
        uint32_t        needsChanged;
        size_t          frameCount;
        mix_t           hook;
        int32_t         *outputTemp;
        int32_t         *resampleTemp;
        int32_t         reserved[2];
        track_t         tracks[32];// __attribute__((aligned(32)));《--把这里注释掉
//否则source insight会解析不了这个state_t类型
    };
    int             mActiveTrack;
    uint32_t        mTrackNames;//names？搞得像字符串，实际是一个int
    const uint32_t  mSampleRate;
state_t         mState
好了，没什么吗。hook对应的可选函数实现有：
process__validate
process__nop
process__genericNoResampling
process__genericResampling
process__OneTrack16BitsStereoNoResampling
process__TwoTracks16BitsStereoNoResampling
AudioMixer构造的时候，hook是process__nop，有几个地方会改变这个函数指针的指向。
这部分涉及到数字音频技术，我就无力讲解了。我们看看最接近的函数
process__OneTrack16BitsStereoNoResampling
void AudioMixer::process__OneTrack16BitsStereoNoResampling(state_t* state, void* output)
{
单track，16bit双声道，不需要重采样,大部分是这种情况了
    const int i = 31 - __builtin_clz(state->enabledTracks);
    const track_t& t = state->tracks[i];
    AudioBufferProvider::Buffer& b(t.buffer);
    int32_t* out = static_cast(output);
    size_t numFrames = state->frameCount;
    const int16_t vl = t.volume[0];
    const int16_t vr = t.volume[1];
    const uint32_t vrl = t.volumeRL;
    while (numFrames) {
        b.frameCount = numFrames;
//获得buffer
        t.bufferProvider->getNextBuffer(&b);
        int16_t const *in = b.i16;
       size_t outFrames = b.frameCount;
       if  UNLIKELY--->不走这.
        else {
            do {
          //计算音量等数据，和数字音频技术有关。这里不说了
                uint32_t rl = *reinterpret_cast(in);
                in += 2;
                int32_t l = mulRL(1, rl, vrl) >> 12;
                int32_t r = mulRL(0, rl, vrl) >> 12;
                *out++ = (r<<16) | (l & 0xFFFF);
            } while (--outFrames);
        }
        numFrames -= b.frameCount;
//释放buffer。
        t.bufferProvider->releaseBuffer(&b);
    }
}
好像挺简单的啊，不就是把数据处理下嘛。这里注意下buffer。到现在，我们还没看到取共享内存里AT端write的数据呐。
那只能到bufferProvider去看了。
注意，这里用的是AudioBufferProvider基类，实际的对象是Track。它从AudioBufferProvider派生。
我们用得是PlaybackThread的这个Track
status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
{
//一阵暗喜吧。千呼万唤始出来，终于见到cblk了
     audio_track_cblk_t* cblk = this->cblk();
     uint32_t framesReady;
     uint32_t framesReq = buffer->frameCount;
 //哈哈，看看数据准备好了没，
      framesReady = cblk->framesReady();
     if (LIKELY(framesReady)) {
        uint32_t s = cblk->server;
        uint32_t bufferEnd = cblk->serverBase + cblk->frameCount;
        bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd : bufferEnd;
        if (framesReq > framesReady) {
            framesReq = framesReady;
        }
        if (s + framesReq > bufferEnd) {
            framesReq = bufferEnd - s;
        }
获得真实的数据地址
         buffer->raw = getBuffer(s, framesReq);
         if (buffer->raw == 0) goto getNextBuffer_exit;
         buffer->frameCount = framesReq;
        return NO_ERROR;
     }
getNextBuffer_exit:
     buffer->raw = 0;
     buffer->frameCount = 0;
    return NOT_ENOUGH_DATA;
}
再看看释放缓冲的地方：releaseBuffer，这个直接在ThreadBase中实现了
void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
{
    buffer->raw = 0;
    mFrameCount = buffer->frameCount;
    step();
    buffer->frameCount = 0;
}
看看step吧。mFrameCount表示我已经用完了这么多帧。
bool AudioFlinger::ThreadBase::TrackBase::step() {
    bool result;
    audio_track_cblk_t* cblk = this->cblk();
result = cblk->stepServer(mFrameCount);//哼哼，调用cblk的stepServer，更新
服务端的使用位置
    return result;
}
到这里，大伙应该都明白了吧。原来AudioTrack中write的数据，最终是这么被使用的呀！！！
恩，看一个process__OneTrack16BitsStereoNoResampling不过瘾，再看看
process__TwoTracks16BitsStereoNoResampling。
void AudioMixer::process__TwoTracks16BitsStereoNoResampling(state_t* state, void*
output)
int i;
    uint32_t en = state->enabledTracks;
    i = 31 - __builtin_clz(en);
    const track_t& t0 = state->tracks[i];
    AudioBufferProvider::Buffer& b0(t0.buffer);
    en &= ~(1<    i = 31 - __builtin_clz(en);
    const track_t& t1 = state->tracks[i];
    AudioBufferProvider::Buffer& b1(t1.buffer);
    int16_t const *in0;
    const int16_t vl0 = t0.volume[0];
    const int16_t vr0 = t0.volume[1];
    size_t frameCount0 = 0;
    int16_t const *in1;
    const int16_t vl1 = t1.volume[0];
    const int16_t vr1 = t1.volume[1];
    size_t frameCount1 = 0;
    int32_t* out = static_cast(output);
    size_t numFrames = state->frameCount;
    int16_t const *buff = NULL;
    while (numFrames) {
        if (frameCount0 == 0) {
            b0.frameCount = numFrames;
            t0.bufferProvider->getNextBuffer(&b0);
            if (b0.i16 == NULL) {
                if (buff == NULL) {
                    buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount];
                }
                in0 = buff;
                b0.frameCount = numFrames;
            } else {
                in0 = b0.i16;
            }
            frameCount0 = b0.frameCount;
        }
        if (frameCount1 == 0) {
            b1.frameCount = numFrames;
            t1.bufferProvider->getNextBuffer(&b1);
            if (b1.i16 == NULL) {
                if (buff == NULL) {
                    buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount];
                }
                in1 = buff;
                b1.frameCount = numFrames;
               } else {
                in1 = b1.i16;
            }
            frameCount1 = b1.frameCount;
        }
        size_t outFrames = frameCount0 < frameCount1?frameCount0:frameCount1;
        numFrames -= outFrames;
        frameCount0 -= outFrames;
        frameCount1 -= outFrames;
        do {
            int32_t l0 = *in0++;
            int32_t r0 = *in0++;
            l0 = mul(l0, vl0);
            r0 = mul(r0, vr0);
            int32_t l = *in1++;
            int32_t r = *in1++;
            l = mulAdd(l, vl1, l0) >> 12;
            r = mulAdd(r, vr1, r0) >> 12;
            // clamping...
            l = clamp16(l);
            r = clamp16(r);
            *out++ = (r<<16) | (l & 0xFFFF);
        } while (--outFrames);
        if (frameCount0 == 0) {
            t0.bufferProvider->releaseBuffer(&b0);
        }
        if (frameCount1 == 0) {
            t1.bufferProvider->releaseBuffer(&b1);
        }
    }  
    if (buff != NULL) {
        delete [] buff;      
    }
}
看不懂了吧？？哈哈，知道有这回事就行了，专门搞数字音频的需要好好研究下了！
三 再论共享audio_track_cblk_t
为什么要再论这个？因为我在网上找了下，有人说audio_track_cblk_t是一个环形buffer，环形buffer是什么意思？自己查查！
这个吗，和我之前的工作经历有关系，某BOSS费尽心机想搞一个牛掰掰的环形buffer，搞得我累死了。现在audio_track_cblk_t是环形buffer？我倒是想看看它是怎么实现的。
顺便我们要解释下，audio_track_cblk_t的使用和我之前说的Lock,读/写，Unlock不太一样。为何？
l         第一因为我们没在AF代码中看到有缓冲buffer方面的wait，MixThread只有当没有数据的时候会usleep一下。
l         第二，如果有多个track，多个audio_track_cblk_t的话，假如又是采用wait信号的办法，那么由于pthread库缺乏WaitForMultiObjects的机制，那么到底该等哪一个？这个问题是我们之前在做跨平台同步库的一个重要难题。
1. 写者的使用
我们集中到audio_track_cblk_t这个类，来看看写者是如何使用的。写者就是AudioTrack端，在这个类中，叫user
l         framesAvailable，看看是否有空余空间
l         buffer，获得写空间起始地址
l         stepUser，更新user的位置。
2. 读者的使用
读者是AF端，在这个类中加server。
l         framesReady，获得可读的位置
l         stepServer，更新读者的位置
看看这个类的定义：
struct audio_track_cblk_t
{
               Mutex       lock; //同步锁
                Condition   cv;//CV
volatile    uint32_t    user;//写者
    volatile    uint32_t    server;//读者
                uint32_t    userBase;//写者起始位置
                uint32_t    serverBase;//读者起始位置
    void*       buffers;
    uint32_t    frameCount;
    // Cache line boundary
    uint32_t    loopStart; //循环起始
    uint32_t    loopEnd; //循环结束
    int         loopCount;
uint8_t     out;   //如果是Track的话，out就是1，表示输出。
}
注意这是volatile，跨进程的对象，看来这个volatile也是可以跨进程的嘛。
l         唉，又要发挥下了。volatile只是告诉编译器，这个单元的地址不要cache到CPU的缓冲中。也就是每次取值的时候都要到实际内存中去读，而且可能读内存的时候先要锁一下总线。防止其他CPU核执行的时候同时去修改。由于是跨进程共享的内存，这块内存在两个进程都是能见到的，又锁总线了，又是同一块内存，volatile当然保证了同步一致性。
l         loopStart和loopEnd这两个值是表示循环播放的起点和终点的，下面还有一个loopCount吗，表示循环播放次数的
那就分析下吧。
先看写者的那几个函数
4 写者分析
先用frameavail看看当前剩余多少空间，我们可以假设是第一次进来嘛。读者还在那sleep呢。
uint32_t audio_track_cblk_t::framesAvailable()
{
    Mutex::Autolock _l(lock);
    return framesAvailable_l();
}
int32_t audio_track_cblk_t::framesAvailable_l()
{
    uint32_t u = this->user; 当前写者位置，此时也为0
    uint32_t s = this->server; //当前读者位置，此时为0
    if (out) { out为1
        uint32_t limit = (s < loopStart) ? s : loopStart;
我们不设循环播放时间吗。所以loopStart是初始值INT_MAX，所以limit=0
        return limit + frameCount - u;
//返回0+frameCount-0，也就是全缓冲最大的空间。假设frameCount=1024帧
    }
}
然后调用buffer获得其实位置，buffer就是得到一个地址位置。
void* audio_track_cblk_t::buffer(uint32_t offset) const
{
    return (int8_t *)this->buffers + (offset - userBase) * this->frameSize;
}
完了，我们更新写者，调用stepUser
uint32_t audio_track_cblk_t::stepUser(uint32_t frameCount)
{
//framecount，表示我写了多少，假设这一次写了512帧
    uint32_t u = this->user;//user位置还没更新呢，此时u=0；
    u += frameCount;//u更新了，u=512
    // Ensure that user is never ahead of server for AudioRecord
    if (out) {
       //没甚，计算下等待时间
}
//userBase还是初始值为0，可惜啊，我们只写了1024的一半
//所以userBase加不了
   if (u >= userBase + this->frameCount) {
        userBase += this->frameCount;
//但是这句话很重要，userBase也更新了。根据buffer函数的实现来看，似乎把这个
//环形缓冲铺直了....连绵不绝。
    }
    this->user = u;//喔，user位置也更新为512了，但是useBase还是0
    return u;
}
好了，假设写者这个时候sleep了，而读者起来了。
5 读者分析
uint32_t audio_track_cblk_t::framesReady()
{
    uint32_t u = this->user; //u为512
    uint32_t s = this->server;//还没读呢，s为零
    if (out) {
        if (u < loopEnd) {
            return u - s;//loopEnd也是INT_MAX，所以这里返回512，表示有512帧可读了
        } else {
            Mutex::Autolock _l(lock);
            if (loopCount >= 0) {
                return (loopEnd - loopStart)*loopCount + u - s;
            } else {
                return UINT_MAX;
            }
        }
    } else {
        return s - u;
    }
}
使用完了，然后stepServer
bool audio_track_cblk_t::stepServer(uint32_t frameCount)
{
    status_t err;
   err = lock.tryLock();
    uint32_t s = this->server;
    s += frameCount; //读了512帧了，所以s=512
    if (out) {
    }
   没有设置循环播放嘛，所以不走这个
    if (s >= loopEnd) {
       s = loopStart;
        if (--loopCount == 0) {
            loopEnd = UINT_MAX;
            loopStart = UINT_MAX;
        }
}
//一样啊，把环形缓冲铺直了
    if (s >= serverBase + this->frameCount) {
        serverBase += this->frameCount;
    }
    this->server = s; //server为512了
    cv.signal(); //读者读完了。触发下写者吧。
    lock.unlock();
    return true;
}
6 真的是环形缓冲吗？
环形缓冲是这样一个场景，现在buffer共1024帧。
假设：
l         写者先写到1024帧
l         读者读到512帧
l         那么，写者还可以从头写512帧。
所以，我们得回头看看frameavail是不是把这512帧算进来了。
uint32_t audio_track_cblk_t::framesAvailable_l()
{
    uint32_t u = this->user;  //1024
    uint32_t s = this->server;//512
    if (out) {
        uint32_t limit = (s < loopStart) ? s : loopStart;
        return limit + frameCount - u;返回512，用上了！
    }
}
再看看stepUser这句话
if (u >= userBase + this->frameCount) {u为1024，userBase为0，frameCount为1024
        userBase += this->frameCount;//好，userBase也为1024了
}
看看buffer
return (int8_t *)this->buffers + (offset - userBase) * this->frameSize;
//offset是外界传入的基于user的一个偏移量。offset-userBase，得到的正式从头开始的那段数据空间。太牛了！