第7章  深入理解Audio系统

说明：在下文中AudioTrack被简写为AT，AudioFlinger被简写为AF，AudioPolicyService被简写为AP。

注意：要了解AudioTrack Java API的具体信息，需要仔细阅读Android API中的相关文档。阅读API文档，是一个能快速掌握相关知识的好方法。

//① 根据音频数据的特性来确定所要分配的缓冲区的最小size

int bufsize =

          AudioTrack.getMinBufferSize(8000,//采样率：每秒8K个点                     

　　      AudioFormat.CHANNEL_CONFIGURATION_STEREO,//声道数：双声道           

        AudioFormat.ENCODING_PCM_16BIT//采样精度：一个采样点16比特，相当于2个字节

);

//② 创建AudioTrack

AudioTrack trackplayer = new AudioTrack(

                 AudioManager.STREAM_MUSIC,//音频流类型

                 8000,AudioFormat.CHANNEL_CONFIGURATION_ STEREO,

　　                 AudioFormat.ENCODING_PCM_16BIT, bufsize,

                 AudioTrack.MODE_STREAM//数据加载模式);

  //③ 开始播放

trackplayer.play() ;

......

//④ 调用write写数据

trackplayer.write(bytes_pkg, 0,bytes_pkg.length) ;//往track中写数据

......

 //⑤ 停止播放和释放资源

trackplayer.stop();//停止播放

trackplayer.release();//释放底层资源

注意：如果采用STATIC模式，须先调用write写数据，然后再调用play。

注意：上面这些类型的划分和音频数据本身并没有关系。例如MUSIC和RING类型都可以是某首MP3歌曲。另外，声音流类型的选择没有固定的标准，例如，铃声预览中的铃声可以设置为MUSIC类型。

//注意这些参数的值。想象我们正在一步步的Trace，这些参数都会派上用场

AudioTrack.getMinBufferSize(8000,//每秒8K个点                              

　　      AudioFormat.CHANNEL_CONFIGURATION_STEREO,//双声道                  

        AudioFormat.ENCODING_PCM_16BIT);

static public int getMinBufferSize(intsampleRateInHz, int channelConfig,  

                                  intaudioFormat) {

       int channelCount = 0;

       switch(channelConfig) {

       case AudioFormat.CHANNEL_OUT_MONO:

        caseAudioFormat.CHANNEL_CONFIGURATION_MONO:

           channelCount = 1;

           break;

       case AudioFormat.CHANNEL_OUT_STEREO:

       case AudioFormat.CHANNEL_CONFIGURATION_STEREO:

           channelCount = 2;//目前最多支持双声道

           break;

        default:

           return AudioTrack.ERROR_BAD_VALUE;

        }

        //目前只支持PCM8和PCM16精度的音频数据   

        if((audioFormat != AudioFormat.ENCODING_PCM_16BIT)

           && (audioFormat != AudioFormat.ENCODING_PCM_8BIT)) {

           return AudioTrack.ERROR_BAD_VALUE;

        }

      //对采样频率也有要求，太低或太高都不行。

        if( (sampleRateInHz < 4000) || (sampleRateInHz > 48000) )

            return AudioTrack.ERROR_BAD_VALUE;

       /*

        调用Native函数，先想想为什么，如果是简单计算，那么Java层做不到吗？

        原来，还需要确认硬件是否支持这些参数，当然得进入Native层查询了

        */

       int size = native_get_min_buff_size(sampleRateInHz,         

                 channelCount,audioFormat);                       

        if((size == -1) || (size == 0)) {

             return AudioTrack.ERROR;

        }

       else {

           return size;

        }

}

说明：HAL对象的具体实现和硬件厂商有关系，如果没有特殊说明，我们则把硬件和HAL作为一种东西讨论。

/*

注意我们传入的参数是：

sampleRateInHertz = 8000，nbChannels = 2

audioFormat = AudioFormat.ENCODING_PCM_16BIT

*/

static jintandroid_media_AudioTrack_get_min_buff_size(                    

                 JNIEnv*env,  jobject thiz,

                 jintsampleRateInHertz, jint nbChannels, jint audioFormat)

{

    intafSamplingRate;

    intafFrameCount;

    uint32_t afLatency;

     /*

        下面这些调用涉及了AudioSystem，这个和AudioPolicy有关系。这里仅把它们看成是

信息查询即可

    */

   //查询采样率，一般返回的是所支持的最高采样率，例如44100

    if(AudioSystem::getOutputSamplingRate(&afSamplingRate) != NO_ERROR) {

       return -1;

}

     //① 查询硬件内部缓冲的大小，以Frame为单位。什么是Frame？

    if(AudioSystem::getOutputFrameCount(&afFrameCount) != NO_ERROR) {

       return -1;

    }

    //查询硬件的延时时间

    if(AudioSystem::getOutputLatency(&afLatency) != NO_ERROR) {

       return -1;

}

......

说明：Frame是一个单位，经多方查寻，最终在ALSA的wiki中找到了对它的解释。Frame直观上用来描述数据量的多少，例如，一帧等于多少字节。1单位的Frame等于1个采样点的字节数×声道数（比如PCM16，双声道的1个Frame等于2×2=4字节）。

我们知道，1个采样点只针对一个声道，而实际上可能会有一或多个声道。由于不能用一个独立的单位来表示全部声道一次采样的数据量，也就引出了Frame的概念。Frame的大小，就是一个采样点的字节数×声道数。另外，在目前的声卡驱动程序中，其内部缓冲区也是采用Frame作为单位来分配和管理的。

   ......

   // minBufCount表示缓冲区的最少个数，它以Frame作为单位

   uint32_t minBufCount = afLatency / ((1000 *afFrameCount)/afSamplingRate);

    if(minBufCount < 2) minBufCount = 2;//至少要两个缓冲

   //计算最小帧个数

   uint32_tminFrameCount =               

         (afFrameCount*sampleRateInHertz*minBufCount)/afSamplingRate;

  //下面根据最小的FrameCount计算最小的缓冲大小   

   intminBuffSize = minFrameCount //计算方法完全符合我们前面关于Frame的介绍

           * (audioFormat == javaAudioTrackFields.PCM16 ? 2 : 1)

           * nbChannels;

    returnminBuffSize;

}

注意：Java空间的分析包括JNI这一层，因为它们二者的关系最为紧密。

AudioTrack trackplayer = new AudioTrack(

                 AudioManager.STREAM_MUSIC,

                 8000,AudioFormat.CHANNEL_CONFIGURATION_ STEREO,

　　                 AudioFormat.ENCODING_PCM_16BIT,bufsize,

                 AudioTrack.MODE_STREAM);

public AudioTrack(int streamType, intsampleRateInHz, int channelConfig,

                 intaudioFormat,int bufferSizeInBytes, int mode)

                  throws IllegalArgumentException {

        mState= STATE_UNINITIALIZED;

        //检查参数是否合法

       audioParamCheck(streamType, sampleRateInHz, channelConfig,

                         audioFormat,mode);

       //bufferSizeInBytes是通过getMinBufferSize得到的，所以下面的检查肯定能通过

       audioBuffSizeCheck(bufferSizeInBytes);

        /*

           调用native层的native_setup，构造一个WeakReference传进去。

           不了解Java WeakReference读者可以上网查一下，很简单

       */

       int initResult = native_setup(new WeakReference<AudioTrack>(this),

         mStreamType,//这个值是AudioManager.STREAM_MUSIC   

         mSampleRate, //这个值是8000       

        mChannels,   //这个值是2

        mAudioFormat,//这个值是AudioFormat.ENCODING_PCM_16BIT      

         mNativeBufferSizeInBytes,//这个值等于bufferSizeInBytes              

        mDataLoadMode);//DataLoadMode是MODE_STREAM       

         ....

}

static int

android_media_AudioTrack_native_setup(JNIEnv*env, jobject thiz,   

                         jobjectweak_this,jint streamType,        

                         jintsampleRateInHertz, jint channels,   

                         jintaudioFormat, jint buffSizeInBytes,  

                         jintmemoryMode)                 

{

    intafSampleRate;

    intafFrameCount;

    //进行一些信息查询

  AudioSystem::getOutputFrameCount(&afFrameCount, streamType)；

  AudioSystem::getOutputSamplingRate(&afSampleRate, streamType)；

  AudioSystem::isOutputChannel(channels)；

   //popCount用于统计一个整数中有多少位为1，有很多经典的算法

int nbChannels = AudioSystem::popCount(channels);

    //Java层的值和JNI层的值转换

    if(streamType == javaAudioTrackFields.STREAM_MUSIC)

         atStreamType = AudioSystem::MUSIC;

   intbytesPerSample = audioFormat == javaAudioTrackFields.PCM16 ? 2 : 1;

   intformat = audioFormat == javaAudioTrackFields.PCM16 ?

                  AudioSystem::PCM_16_BIT : AudioSystem::PCM_8_BIT;

    //计算以帧为单位的缓冲大小

    intframeCount = buffSizeInBytes / (nbChannels * bytesPerSample);

     //① AudioTrackJniStorage对象，它保存了一些信息，后面将详细分析

   AudioTrackJniStorage* lpJniStorage = new AudioTrackJniStorage();

      ......

     //②创建Native层的AudioTrack对象

   AudioTrack* lpTrack = new AudioTrack();

       if(memoryMode == javaAudioTrackFields.MODE_STREAM) {

       //③STREAM模式

      lpTrack->set(

           atStreamType,//指定流类型

           sampleRateInHertz,

           format,// 采样点的精度，一般为PCM16或者PCM8

           channels,

           frameCount,

           0,// flags

           audioCallback, //该回调函数定义在android_media_AudioTrack.cpp中   

        &(lpJniStorage->mCallbackData),

           0,

           0,// 共享内存,STREAM模式下为空。实际使用的共享内存由AF创建

           true);//内部线程可以调用JNI函数，还记得“zygote偷梁换柱”那一节吗？

         } else if (memoryMode == javaAudioTrackFields.MODE_STATIC) {

          //如果是static模式，需要先创建共享内存

         lpJniStorage->allocSharedMem(buffSizeInBytes);

         lpTrack->set(

           atStreamType,// stream type

           sampleRateInHertz,

           format,// word length, PCM

           channels,

           frameCount,

           0,// flags

           audioCallback,

          &(lpJniStorage->mCallbackData),

           0,

           lpJniStorage->mMemBase, //STATIC模式下，需要传递该共享内存

           true);

    }

    ......

    /*

      把JNI层中new出来的AudioTrack对象指针保存到Java对象的一个变量中，

      这样就把JNI层的AudioTrack对象和Java层的AudioTrack对象关联起来了，

     这是Android的常用技法。                        

   */   

     env->SetIntField(thiz,javaAudioTrackFields.nativeTrackInJavaObj,

                     (int)lpTrack);

   // lpJniStorage对象指针也保存到Java对象中

   env->SetIntField(thiz, javaAudioTrackFields.jniData,(int)lpJniStorage);

  }

注意，这个文件也可以是设备文件。一般来说，mmap函数的具体工作由参数中的那个文件描述符所对应的驱动或内核模块来完成。

//下面这个结构就是保存一些变量，没有什么特别的作用

struct audiotrack_callback_cookie {

   jclass      audioTrack_class;

   jobject     audioTrack_ref;

 };

class AudioTrackJniStorage {

   public:

       sp<MemoryHeapBase>    mMemHeap;//这两个Memory很重要

       sp<MemoryBase>         mMemBase;

       audiotrack_callback_cookie mCallbackData;

       int                       mStreamType;

      boolallocSharedMem(int sizeInBytes) {

     /* 

      注意关于MemoryHeapBase和MemoryBase的用法。   

      先new一个MemoryHeapBase，再以它为参数new一个MemoryBase        

    */  

   //① MemoryHeapBase

    mMemHeap = new MemoryHeapBase(sizeInBytes, 0,"AudioTrack Heap Base");

   //②MemoryBase

    mMemBase= new MemoryBase(mMemHeap, 0, sizeInBytes);

    return true;

   }

};

mMemHeap = new MemoryHeapBase(sizeInBytes, 0,"AudioTrack Heap Base");

/*

   MemoryHeapBase有两个构造函数，我们用的是第一个。

  size表示共享内存大小，flags为0，name为"AudioTrackHeap Base"

*/

MemoryHeapBase::MemoryHeapBase(size_t size,uint32_t flags,char const * name)

    :mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

     mDevice(0), mNeedUnmap(false)

{

    constsize_t pagesize = getpagesize();//获取系统中的内存页大小，一般为4KB

    size =((size + pagesize-1) & ~(pagesize-1));

   /*   

     创建共享内存，ashmem_create_region函数由libcutils提供。

     在真实设备上将打开/dev/ashmem设备得到一个文件描述符,在模拟器上则创建一个tmp文件    

  */

   int fd= ashmem_create_region(name == NULL ? "MemoryHeapBase" : name, size);

  //下面这个函数将通过mmap方式得到内存地址，这是Linux的标准做法，有兴趣的读者可以看看

   mapfd(fd,size);

}

MemoryHeapBase::getBaseID() //返回mFd，如果为负数，表明刚才创建共享内存失败了

MemoryHeapBase::getBase()  //共享内存起始地址

MemoryHeapBase::getSize() //返回mSize，表示内存大小

说明：Android系统通过ashmem创建共享内存的原理，和Linux系统中通过打开文件创建共享内存的原理类似，但ashmem设备驱动在这方面做了较大的改进，例如增加了引用计数、延时分配物理内存的机制（即真正使用的时候才去分配内存）等。这些内容，感兴趣的读者还可以自行对其研究。

class MemoryBase : public BnMemory

{

public:

   MemoryBase(const sp<IMemoryHeap>& heap,ssize_t offset, size_tsize);

   virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size)const;

protected:

    size_tgetSize() const { return mSize; }//返回大小

    ssize_tgetOffset() const { return mOffset;}//返回偏移量

    //返回MemoryHeapBase对象     

    constsp<IMemoryHeap>& getHeap() const { return mHeap;}

};

//MemoryBase的构造函数

MemoryBase::MemoryBase(constsp<IMemoryHeap>& heap,ssize_t offset, size_t size)

    :mSize(size), mOffset(offset), mHeap(heap)

{

}

提醒：这两个类没有提供同步对象来保护这块共享内存，所以后续在使用这块内存时，必然需要一个跨进程的同步对象来保护它。这一点，是我在AT中第一次见到它们时想到的，不知道你是否注意过这个问题。

//③ 开始播放

trackplayer.play() ;

//④ 调用write写数据

trackplayer.write(bytes_pkg, 0,bytes_pkg.length) ;//往track中写数据

static void

android_media_AudioTrack_start(JNIEnv *env,jobject thiz)

{

/*

  从Java的AudioTrack对象中获取对应Native层的AudioTrack对象指针。

 从int类型直接转换成指针，不过要是以后ARM平台支持64位指针了，代码就得大修改了。

*/

   AudioTrack *lpTrack = (AudioTrack *)env->GetIntField(

        thiz,javaAudioTrackFields.nativeTrackInJavaObj);

   lpTrack->start(); //很简单的调用

}

static jint android_media_AudioTrack_native_write_short(

                 JNIEnv*env,  jobject thiz,

                 jshortArrayjavaAudioData,jint offsetInShorts,

                 jintsizeInShorts,jint javaAudioFormat) {

        return(android_media_AudioTrack_native_write(

                 env,thiz,(jbyteArray)javaAudioData,offsetInShorts*2,

                 sizeInShorts*2,javaAudioFormat)/ 2);

}

jint writeToTrack(AudioTrack* pTrack, jintaudioFormat,

                 jbyte*data,jint offsetInBytes, jint sizeInBytes) {

   ssize_t written = 0;

  /*

     如果是STATIC模式，sharedBuffer()返回不为空

     如果是STREAM模式，sharedBuffer()返回空

  */

      if (pTrack->sharedBuffer() == 0) {

         //我们的用例是STREAM模式，调用write函数写数据

       written = pTrack->write(data + offsetInBytes, sizeInBytes);

    } else{

        if (audioFormat == javaAudioTrackFields.PCM16){

           if ((size_t)sizeInBytes > pTrack->sharedBuffer()->size()) {

               sizeInBytes = pTrack->sharedBuffer()->size();

           }

        //在STATIC模式下，直接把数据memcpy到共享内存，记住在这种模式下要先调用write

        //后调用play

          memcpy(pTrack->sharedBuffer()->pointer(),

                         data+ offsetInBytes, sizeInBytes);

           written = sizeInBytes;

        }else if (audioFormat == javaAudioTrackFields.PCM8) {

          //如果是PCM8数据，则先转换成PCM16数据再拷贝

           ......

    }

    returnwritten;

}

static voidandroid_media_AudioTrack_native_release(JNIEnv *env,  jobject thiz) {

    //调用android_media_AudioTrack_native_finalize真正释放资源

   android_media_AudioTrack_native_finalize(env, thiz);

    //之前保存在Java对象中的指针变量此时都要设置为零

   env->SetIntField(thiz, javaAudioTrackFields.nativeTrackInJavaObj, 0);

   env->SetIntField(thiz, javaAudioTrackFields.jniData, 0);

}

static voidandroid_media_AudioTrack_native_finalize(JNIEnv *env, jobject thiz) {

   AudioTrack *lpTrack = (AudioTrack *)env->GetIntField(

                           thiz, javaAudioTrackFields.nativeTrackInJavaObj);

    if(lpTrack) {

       lpTrack->stop();//调用stop

       delete lpTrack; //调用AudioTrack的析构函数

}

......

}

说明：为什么要总结流程呢？

第一：控制了流程，就把握了系统工作的命脉，这一点至关重要。

第二：有些功能的实现纵跨Java/Native层，横跨两个进程，这中间有很多封装、很多的特殊处理，但是其基本流程是不变的。通过精简流程，我们才能把注意力集中在关键点上。

AudioTrack::AudioTrack()//我们使用无参构造函数

    :mStatus(NO_INIT)

{

  //把状态初始化成NO_INIT。Android的很多类都采用了这种状态控制

}

/* 

   还记得我们传入的参数吗？

 streamType=STREAM_MUSIC,sampleRate=8000,format=PCM_16

 channels=2，frameCount由计算得来，可以假设一个值，例如1024，不影响分析。

  flags=0,cbf=audiocallback, user为cbf的参数，notificationFrames=0

  因为是流模式，所以sharedBuffer=0。threadCanCallJava 为true

*/

status_t AudioTrack::set(int streamType,uint32_t sampleRate,int format,

       int channels,int frameCount,uint32_t flags,callback_t cbf,void* user,

       int notificationFrames,const sp<IMemory>& sharedBuffer,

        boolthreadCanCallJava)

{

    //前面有一些判断，都是和AudioSystem有关的，以后再分析

    ......

  /*

     audio_io_handle_t是一个int类型，通过typedef定义，这个值的来历非常复杂，

涉及AudioFlinger和AudioPolicyService， 后边的分析试将其解释清楚。

这个值主要被AudioFlinger使用，用来表示内部的工作线程索引号。AudioFlinger会根据

情况创建几个工作线程，下面的AudioSystem::getOutput会根据流类型等其他参数最终选

取一个合适的工作线程，并返回它在AF中的索引号。

而AudioTrack一般使用混音线程（Mixer Thread）

 */

    audio_io_handle_toutput = AudioSystem::getOutput(

                         (AudioSystem::stream_type)streamType,

                          sampleRate,format, channels,

                         (AudioSystem::output_flags)flags);

   //调用creatTrack

   status_t status = createTrack(streamType, sampleRate, format,channelCount,

                                  frameCount,flags, sharedBuffer, output);

//cbf是JNI层传入的回调函数audioCallback，如果用户设置了回调函数，则启动一个线程

  if (cbf!= 0) {

       mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);

   }

   returnNO_ERROR;

}

status_t AudioTrack::createTrack(intstreamType,uint32_t sampleRate,

       int format,int channelCount,int frameCount, uint32_t flags,

       const sp<IMemory>& sharedBuffer, audio_io_handle_t output)

{

   status_tstatus;

  /*

    得到AudioFlinger的Binder代理端BpAudioFlinger。

    关于这部分内容，我们已经很熟悉了，以后的讲解会跨过Binder，直接分析Bn端的实现

  */

  constsp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();

 /*

向AudioFinger发送createTrack请求。注意其中的几个参数，

在STREAM模式下sharedBuffer为空

    output为AudioSystem::getOutput得到一个值，代表AF中的线程索引号

该函数返回IAudioTrack（实际类型是BpAudioTrack）对象，后续AF和AT的交互就是

围绕IAudioTrack进行的

*/

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

        streamType,sampleRate,format,channelCount,frameCount,

        ((uint16_t)flags) << 16,sharedBuffer,output,&status);

   /*

     在STREAM模式下，没有在AT端创建共享内存，但前面提到了AT和AF的数据交互是

通过共享内存完成的，这块共享内存最终由AF的createTrack创建。我们以后分析AF时

再做介绍。下面这个调用会取出AF创建的共享内存

*/

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

   mAudioTrack.clear();//sp的clear

    mAudioTrack= track;

   mCblkMemory.clear();

    mCblkMemory= cblk;//cblk是control block的简写

  /*

    IMemory的pointer在此处将返回共享内存的首地址，类型为void*，

    static_cast直接把这个void*类型转成audio_track_cblk_t，表明这块内存的首部中存在

     audio_track_cblk_t这个对象

  */

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

   mCblk->out = 1;//out为1表示输出，out为0表示输入

   mFrameCount = mCblk->frameCount;

    if(sharedBuffer == 0) {

       //buffers指向数据空间，它的起始位置是共享内存的首部加上audio_track_cblk_t的大小

       mCblk->buffers= (char*)mCblk + sizeof(audio_track_cblk_t);

  } else {

       //STATIC模式下的处理

        mCblk->buffers =sharedBuffer->pointer();

        mCblk->stepUser(mFrameCount);//更新数据位置，后面要分析stepUser的作用

    }

    returnNO_ERROR;

}

struct audio_track_cblk_t

{

       Mutex       lock;

       Condition   cv;//这是两个同步变量，初始化的时候会设置为支持跨进程共享

  /*

   一块数据缓冲同时被生产者和消费者使用，最重要的就是维护它的读写位置了。

   下面定义的这些变量就和读写的位置有关，虽然它们的名字并不是那么直观。

   另外，这里提一个扩展问题，读者可以思考一下：

  volatile支持跨进程吗？要回答这个问题需要理解volatile、CPU Cache机制和共享内存的本质

 */

   volatile    uint32_t    user;   //当前写位置（即生产者已经写到什么位置了）

    volatile    uint32_t   server;  //当前读位置

 /*

    userBase和serverBase要和user及server结合起来用。

    CB巧妙地通过上面几个变量把一块线性缓冲当做环形缓冲来使用，以后将单独分析这个问题

  */

               uint32_t    userBase;  //

               uint32_t    serverBase;

   void*       buffers; //指向数据缓冲的首地址

   uint32_t    frameCount;//数据缓冲的总大小，以Frame为单位

   uint32_t    loopStart; //设置打点播放（即设置播放的起点和终点）

   uint32_t    loopEnd;

     int         loopCount;//循环播放的次数

   volatile    union {

                    uint16_t    volume[2];

                    uint32_t    volumeLR;

                }; //和音量有关系，可以不管它

     uint32_t    sampleRate;//采样率

    uint32_t    frameSize;//一单位Frame的数据大小

    uint8_t     channels;//声道数

     uint8_t     flowControlFlag;//控制标志，见下文分析

    uint8_t     out; // AudioTrack为1，AudioRecord为0

    uint8_t     forceReady;

    uint16_t    bufferTimeoutMs;

     uint16_t    waitTimeMs;

      //下面这几个函数很重要，后续会详细介绍它们

    uint32_t    stepUser(uint32_tframeCount);//更新写位置

    bool        stepServer(uint32_tframeCount);//更新读位置

    void*       buffer(uint32_toffset) const;//返回可写空间起始位置

    uint32_t    framesAvailable();//还剩多少空间可写

    uint32_t    framesAvailable_l();

    uint32_t    framesReady();//是否有可读数据

}

说明：目前这个参数并不直接和音频输入输出设备的状态有关系。它在AT和AF中的作用必须结合具体情况，才能分析。

注意：CB实际是按照环形缓冲来处理数据读写的，所以user和server的真实作用还需要结合userBase和serverBase。图7-4只是一个示意图。

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

 说明：关于audio_track_cblk_t的使用方式，后文会有详细分析。

enum event_type {

       EVENT_MORE_DATA = 0, //表示AudioTrack需要更多数据

        EVENT_UNDERRUN = 1,//这是Audio的一个术语，表示Audio硬件处于低负荷状态

       //AT可以设置打点播放，即设置播放的起点和终点,LOOP_END表示已经到达播放终点

        EVENT_LOOP_END= 2,

   /*

     数据使用警戒通知。该值可通过setMarkerPosition ()设置。

     当数据使用超过这个值时，AT会且仅通知一次，有点像WaterMarker。

      这里所说的数据使用，是针对消费者AF消费的数据量而言的

   */

       EVENT_MARKER = 3,

    /*

      数据使用进度通知。进度通知值由setPositionUpdatePeriod()设置，

      例如每使用500帧通知一次

    */

       EVENT_NEW_POS = 4,

       EVENT_BUFFER_END = 5   //数据全部被消耗

    };

bool AudioTrack::AudioTrackThread::threadLoop()

{

  //mReceiver就是创建该线程的AudioTrack

  returnmReceiver.processAudioBuffer(this);

}

bool AudioTrack::processAudioBuffer(constsp<AudioTrackThread>& thread)

{

    BufferaudioBuffer;

   uint32_t frames;

    size_twrittenSize;

    //处理underun的情况

    if(mActive && (mCblk->framesReady() == 0)) {

        if(mCblk->flowControlFlag == 0) {

           mCbf(EVENT_UNDERRUN, mUserData, 0);//under run 通知

           if (mCblk->server == mCblk->frameCount) {

        /*

             server是读位置，frameCount是buffer中的数据总和

             当读位置等于数据总和时，表示数据都已经使用完了

          */

               mCbf(EVENT_BUFFER_END, mUserData, 0);

           }

           mCblk->flowControlFlag = 1;

           if (mSharedBuffer != 0) return false;

        }

    }

    // 循环播放通知

    while(mLoopCount > mCblk->loopCount) {

       int loopCount = -1;

       mLoopCount--;

        if(mLoopCount >= 0) loopCount = mLoopCount;

        //一次循环播放完毕，loopCount表示还剩多少次

       mCbf(EVENT_LOOP_END, mUserData, (void *)&loopCount);

    }

     if(!mMarkerReached && (mMarkerPosition > 0)) {

        if(mCblk->server >= mMarkerPosition) {

         //如果数据使用超过警戒值，则通知用户

           mCbf(EVENT_MARKER, mUserData, (void *)&mMarkerPosition);

           //只通知一次，因为该值被设为true

           mMarkerReached = true;

        }

    }

    if(mUpdatePeriod > 0) {

       while (mCblk->server >= mNewPosition) {

       /*

          进度通知，但它不是以时间为基准，而是以帧数为基准的。

          例如设置每500帧通知一次，假设消费者一次就读了1500帧，那么这个循环会连续通知3次

       */

           mCbf(EVENT_NEW_POS, mUserData, (void *)&mNewPosition);

           mNewPosition += mUpdatePeriod;

        }

    }

    if(mSharedBuffer != 0) {

       frames = 0;

    } else{

       frames = mRemainingFrames;

    }

    do {

       audioBuffer.frameCount = frames;

       //得到一块可写的缓冲

       status_t err = obtainBuffer(&audioBuffer, 1);

        ......

       //从用户那pull数据

       mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);

       writtenSize = audioBuffer.size;

        ......

        if(writtenSize > reqSize) writtenSize = reqSize;

       //PCM8数据转PCM16

        .......

       audioBuffer.size = writtenSize;

       audioBuffer.frameCount = writtenSize/mCblk->frameSize;

       frames -= audioBuffer.frameCount;

       releaseBuffer(&audioBuffer);//写完毕，释放这块缓冲

    }

    while(frames);

   　......

    returntrue;

}

static void audioCallback(int event, void* user,void *info) {

    if(event == AudioTrack::EVENT_MORE_DATA) {

         //很好，没有提供数据，也就是说，虽然AudioTrackThread通知了EVENT_MORE_DATA，

        //但是我们并没有提供数据给它

       AudioTrack::Buffer* pBuff = (AudioTrack::Buffer*)info;

       pBuff->size = 0;  

     }

    ......

重点强调：带着问题和思考来分析代码相当于“智取”，它比一上来就直接扎入源码的“强攻”要高明得多。希望我们能掌握这种思路和方法。

ssize_t AudioTrack::write(const void* buffer,size_t userSize)

{

  if(mSharedBuffer != 0) return INVALID_OPERATION;

    if(ssize_t(userSize) < 0) {

       returnBAD_VALUE;

    }

   ssize_t written = 0;

    constint8_t *src = (const int8_t *)buffer;

    BufferaudioBuffer; // Buffer是一个辅助性的结构

 do {

        //以帧为单位

       audioBuffer.frameCount = userSize/frameSize();

        //obtainBuffer从共享内存中得到一块空闲的数据块

        status_terr = obtainBuffer(&audioBuffer, -1);

        ......

       size_t toWrite;

        if(mFormat == AudioSystem::PCM_8_BIT &&

                          !(mFlags &AudioSystem::OUTPUT_FLAG_DIRECT)) {

             //PCM8数据转PCM16

        }else {

           //空闲数据缓冲的大小是audioBuffer.size。

         //地址在audioBuffer.i8中，数据传递通过memcpy完成

           toWrite = audioBuffer.size;

           memcpy(audioBuffer.i8, src, toWrite);

           src += toWrite;

        }

       userSize -= toWrite;

       written += toWrite;

       //releaseBuffer更新写位置，同时会触发消费者

       releaseBuffer(&audioBuffer);

    }while (userSize);

    returnwritten;

}

status_t AudioTrack::obtainBuffer(Buffer*audioBuffer, int32_t waitCount)

{

    intactive;

   status_t result;

   audio_track_cblk_t* cblk = mCblk;

    ......

   //①调用framesAvailable，得到当前可写的空间大小

   uint32_t framesAvail = cblk->framesAvailable();

    if(framesAvail == 0) {

        ......

        //如果没有可写空间，则要等待一段时间

        result= cblk->cv.waitRelative(cblk->lock,milliseconds(waitTimeMs));

          ......

    }

   cblk->waitTimeMs = 0;

    if(framesReq > framesAvail) {

       framesReq = framesAvail;

    }

    //user为可写空间起始地址

   uint32_t u = cblk->user;

   uint32_tbufferEnd = cblk->userBase + cblk->frameCount;

    if (u+ framesReq > bufferEnd) {

       framesReq = bufferEnd - u;

    }

     ......

    //②调用buffer，得到可写空间的首地址

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

    active= mActive;

    returnactive ? status_t(NO_ERROR) : status_t(STOPPED);

}

void AudioTrack::releaseBuffer(Buffer*audioBuffer)

{

   audio_track_cblk_t* cblk = mCblk;

   cblk->stepUser(audioBuffer->frameCount);// ③调用stepUser更新写位置

}

AudioTrack::~AudioTrack()

{

    if(mStatus == NO_ERROR) {

       stop();//调用stop

        if(mAudioTrackThread != 0) {

           //通知AudioTrackThread退出

           mAudioTrackThread->requestExitAndWait();

           mAudioTrackThread.clear();

        }

       mAudioTrack.clear();

     //将残留在IPCThreadState 发送缓冲区的信息发送出去

        IPCThreadState::self()->flushCommands();

    }

}

void AudioTrack::stop()

{

   sp<AudioTrackThread> t = mAudioTrackThread;

    if (t!= 0) {

       t->mLock.lock();

    }

    if(android_atomic_and(~1, &mActive) == 1) {

       mCblk->cv.signal();

     /*

        mAudioTrack是IAudioTrack类型，其stop的最终处理在AudioFlinger端

      */

       mAudioTrack->stop();

       //清空循环播放设置

        setLoop(0, 0, 0);

         mMarkerReached = false;

        if (mSharedBuffer != 0) {

           flush();

        }

        if(t != 0) {

           t->requestExit();//请求退出AudioTrackThread

        }else {

           setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_NORMAL);

        }

    }

    if (t!= 0) {

        t->mLock.unlock();

    }

}

int main(int argc, char** argv)

{

  sp<ProcessState> proc(ProcessState::self());

   sp<IServiceManager>sm = defaultServiceManager();

    ....

   //很好，AF和APS都驻留在这个进程

    AudioFlinger::instantiate();

    AudioPolicyService::instantiate();

     ....

   ProcessState::self()->startThreadPool();

   IPCThreadState::self()->joinThreadPool();

}

void AudioFlinger::instantiate() {

   defaultServiceManager()->addService( //把AF添加到ServiceManager中

           String16("media.audio_flinger"), new AudioFlinger());

}

AudioFlinger::AudioFlinger(): BnAudioFlinger(),

       mAudioHardware(0), //代表Audio硬件的HAL对象

       mMasterVolume(1.0f),mMasterMute(false), mNextThreadId(0)

{

   mHardwareStatus= AUDIO_HW_IDLE;

   //创建代表Audio硬件的HAL对象

   mAudioHardware = AudioHardwareInterface::create();

   mHardwareStatus = AUDIO_HW_INIT;

    if(mAudioHardware->initCheck() == NO_ERROR) {

     //设置系统初始化的一些值，有一部分通过Audio HAL设置到硬件中

       setMode(AudioSystem::MODE_NORMAL);

       setMasterVolume(1.0f);

       setMasterMute(false);

    }

}

class AudioHardwareInterface

{

public:

   virtual ~AudioHardwareInterface() {}

     //用于检查硬件是否初始化成功，返回的错误码定义在include/utils/Errors.h

   virtual status_t    initCheck() =0;

    //设置通话音量，范围从0到1.0

   virtual status_t   setVoiceVolume(float volume) = 0;

    /*

       设置除通话音量外的其他所有音频流类型的音量，范围从0到1.0，如果硬件不支持的话，

       这个功能会由软件层的混音器完成

     */

   virtual status_t   setMasterVolume(float volume) = 0;

    /*

       设置模式，NORMAL的状态为普通模式，RINGTONE表示来电模式（这时听到的声音是来电铃声）

      IN_CALL表示通话模式（这时听到的声音是手机通话过程中的语音）

     */

   virtual status_t    setMode(intmode) = 0;

    // 和麦克相关

   virtual status_t   setMicMute(bool state) = 0;

   virtual status_t   getMicMute(bool* state) = 0;

    // 设置/获取配置参数，采用key/value的组织方式

   virtual status_t   setParameters(const String8& keyValuePairs) = 0;

   virtual String8    getParameters(const String8& keys) = 0;

    // 根据传入的参数得到输入缓冲的大小，返回0表示其中某个参数的值Audio HAL不支持

     virtualsize_t    getInputBufferSize(uint32_tsampleRate, int format,

                                                int channelCount) = 0;

        /*下面这几个函数非常重要 */

     /*

         openOutputStream：创建音频输出流对象（相当于打开音频输出设备）

         AF可以往其中write数据，指针型参数将返回该音频输出流支持的类型、声道数、采样率等

    */

   virtual AudioStreamOut* openOutputStream(

                                uint32_tdevices,

                                int *format=0,

                                uint32_t*channels=0,

                                uint32_t*sampleRate=0,

                                status_t*status=0) = 0;

   //关闭音频输出流

    virtual    void       closeOutputStream(AudioStreamOut* out) = 0;

    /* 创建音频输入流对象（相当于打开音频输入设备），AF可以read数据*/

   virtual AudioStreamIn* openInputStream(

                                uint32_tdevices,

                                int *format,

                                uint32_t*channels,

                                uint32_t *sampleRate,

                                status_t*status,

                               AudioSystem::audio_in_acoustics acoustics) = 0;

   virtual    void        closeInputStream(AudioStreamIn* in) =0;

    //关闭音频输入流

   virtual status_t dumpState(int fd, const Vector<String16>&args) = 0;

    //静态create函数，使用设计模式中的工厂模式，具体返回的对象由厂商根据硬件的情况决定

    staticAudioHardwareInterface* create();

    ......

};

说明：AudioHardwareInterface最重要的功能是创建AudioStreamOut 和AudioStreamIn，它们分别代表音频输出设备和音频输入设备。从这个角度说，是AudioHardwareInterface管理着系统中所有的音频设备。Android引入的HAL层，大大简化了应用层的工作，否则不管是使用libasound（AlSA提供的用户空间库）还是ioctl来控制音频设备，都会非常麻烦。

sp<IAudioTrack> AudioFlinger::createTrack(

       pid_t pid,//AT的pid号

       int streamType,//流类型，用例中是MUSIC类型

       uint32_t sampleRate,//8000 采样率

       int format,//PCM_16类型

       int channelCount,//2，双声道

       int frameCount,//需要创建缓冲的大小，以帧为单位

       uint32_t flags,

       const sp<IMemory>& sharedBuffer,//AT传入的共享buffer，这里为空

       int output,//这个值前面提到过，是AF中的工作线程索引号

       status_t *status)

{

   sp<PlaybackThread::Track> track;

   sp<TrackHandle> trackHandle;

   sp<Client> client;

    wp<Client>wclient;

   status_t lStatus;

   {

       Mutex::Autolock _l(mLock);

        //output代表索引号，这里根据索引号找到一个工作线程，它是一个PlaybackThread

       PlaybackThread *thread = checkPlaybackThread_l(output);

       //看看这个进程是否已经是AF的Client,AF根据进程pid来标识不同的Client

         wclient = mClients.valueFor(pid);

        if(wclient != NULL) {

       }else {

        //如果还没有这个Client信息，则创建一个，并加入到mClients中去

           client = new Client(this, pid);

           mClients.add(pid, client);

        }

      //在找到的工作线程对象中创建一个Track,注意它的类型是Track

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

               channelCount, frameCount, sharedBuffer, &lStatus);

    }

   /*

    TrackHandle是Track对象的Proxy，它支持Binder通信，而Track不支持Binder

    TrackHandle所接收的请求最终会由Track处理，这是典型的Proxy模式

   */

   trackHandle= new TrackHandle(track);

   returntrackHandle;

}

AudioFlinger::PlaybackThread *

                 AudioFlinger::checkPlaybackThread_l(intoutput) const

{

  PlaybackThread*thread = NULL;

  //根据output的值找到对应的thread

    if(mPlaybackThreads.indexOfKey(output) >= 0) {

       thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get();

    }

    returnthread;

}

// Android的很多代码都采用了内部类的方式进行封装，看习惯就好了

sp<AudioFlinger::PlaybackThread::Track>

     AudioFlinger::PlaybackThread::createTrack_l(

       const sp<AudioFlinger::Client>& client,int streamType,

        uint32_tsampleRate,int format,int channelCount,int frameCount,

       const sp<IMemory>& sharedBuffer,//注意这个参数，从AT中传入，为0

       status_t *status)

{

   sp<Track> track;

   status_t lStatus;

    {

       Mutex::Autolock _l(mLock);

      //创建Track对象

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

                      channelCount, frameCount,sharedBuffer);

      //将新创建的Track加入到内部数组mTracks中

      mTracks.add(track);

}

   lStatus= NO_ERROR;

   returntrack;

}

AudioFlinger::PlaybackThread::Track::Track(const wp<ThreadBase>& thread,

           const sp<Client>& client,int streamType,uint32_t sampleRate,

           int format,int channelCount,int frameCount,

            const sp<IMemory>& sharedBuffer)

:  TrackBase(thread, client, sampleRate, format, channelCount,

    frameCount,0, sharedBuffer),//sharedBuffer仍然为空

   mMute(false), mSharedBuffer(sharedBuffer), mName(-1)

{

   // mCblk!=NULL? 什么时候创建的呢？只能看基类TrackBase的构造函数了

   if(mCblk != NULL) {

      mVolume[0] = 1.0f;

      mVolume[1] = 1.0f;

      mStreamType = streamType;

      mCblk->frameSize = AudioSystem::isLinearPCM(format) ?

                              channelCount * sizeof(int16_t): sizeof(int8_t);

    }

}

AudioFlinger::ThreadBase::TrackBase::TrackBase(

           const wp<ThreadBase>& thread,const sp<Client>&client,

           uint32_t sampleRate,int format,int channelCount,int frameCount,

           uint32_t flags,const sp<IMemory>& sharedBuffer)

    :   RefBase(), mThread(thread),mClient(client),mCblk(0),

        mFrameCount(0),mState(IDLE),mClientTid(-1),mFormat(format),

       mFlags(flags & ~SYSTEM_FLAGS_MASK)

{

    size_tsize = sizeof(audio_track_cblk_t);//得到CB对象大小

   //计算数据缓冲大小

   size_tbufferSize = frameCount*channelCount*sizeof(int16_t);

   if(sharedBuffer == 0) {

    //还记得图7-4吗？共享内存最前面一部分是audio_track_cblk_t，后面才是数据空间

      size+= bufferSize;

   }

   //根据size创建一块共享内存。

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

   /*

      pointer()返回共享内存的首地址， 并强制转换void*类型为audio_track_cblk_t*类型。

      其实把它强制转换成任何类型都可以，但是这块内存中会有CB对象吗？

   */

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

    //①下面这句代码看起来很独特。什么意思？？？

     new(mCblk)audio_track_cblk_t();

     mCblk->frameCount = frameCount;

     mCblk->sampleRate = sampleRate;

     mCblk->channels = (uint8_t)channelCount;

     if (sharedBuffer == 0) {

       //清空数据区

      mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);

      memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));

      // flowControlFlag初始值为1

      mCblk->flowControlFlag = 1;

     }

      ......

}

new(mCblk) audio_track_cblk_t();

重点说明：这个语句就是C++语言中的placement new。其含义是在括号里指定的内存中创建一个对象。我们知道，普通的new只能在堆上创建对象，堆的地址由系统分配。这里采用placementnew将使得audio_track_cblk_t创建在共享内存上，它就自然而然地能被多个进程看见并使用了。关于placementnew较详细的知识，还请读者自己搜索一下。

sp<IAudioTrack> AudioFlinger::createTrack（......）

{

    sp<TrackHandle>trackHandle;

    ......

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

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

   trackHandle= new TrackHandle(track);

   return trackHandle;//① 这个trackHandle对象竟然没有在AF中保存！

 }

讨论：Android为什么不直接让Track从IBinder派生，直接支持Binder通信呢？关于这个问题，在看到后面的Track家族图谱后，我们或许就明白了。

拓展思考：关于这个问题的答案，请读者自己思考并回答。提示，可从Binder和RefBase入手。

class AudioFlinger : public BnAudioFlinger,public IBinder::DeathRecipient

class Client : public RefBase {

   public:

       Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);

       virtual             ~Client();

       const sp<MemoryDealer>&    heap() const;

       pid_t               pid() const

        sp<AudioFlinger>    audioFlinger() { return mAudioFlinger; }

   private:

                            Client(constClient&);

                            Client&operator = (const Client&);

       sp<AudioFlinger>   mAudioFlinger;

       sp<MemoryDealer>   mMemoryDealer;//内存分配器

       pid_t                  mPid;

    };

注意：一个Client进程可以创建多个AudioTrack，这些AudioTrack都属于一个Client。

说明：大部分常见音频输出使用的是MixerThread，后文会对此进行详细分析。另外，在拓展内容中，也将深入分析DuplicatingThread的实现。

注意：这里把RecordTrack也统称为Track。

说明：从图7-10也能看出，之所以不让Track继承Binder框架，是因为Track本身的继承关系和所承担的工作已经很复杂了，如再让它掺合Binder，只会乱上添乱。

AudioFlinger::PlaybackThread *

        AudioFlinger::checkPlaybackThread_l(intoutput) const

{

  PlaybackThread*thread = NULL;

  //根据output的值找到对应的thread

    if(mPlaybackThreads.indexOfKey(output) >= 0) {

       thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get();

  }

    returnthread;

}

AudioPolicyService::AudioPolicyService()

    :BnAudioPolicyService() , mpPolicyManager(NULL)

{

    charvalue[PROPERTY_VALUE_MAX];

    // Tone音播放线程

   mTonePlaybackThread = new AudioCommandThread(String8(""));

    // 命令处理线程

   mAudioCommandThread = newAudioCommandThread(String8("ApmCommandThread"));

#if (defined GENERIC_AUDIO) || (defined AUDIO_POLICY_TEST)

    //这里属于Generic的情况，所以构造AudioPolicyManagerBase，注意构造函数的参数

   mpPolicyManager = new AudioPolicyManagerBase(this);

#else

......

    //创建和硬件厂商相关的AudioPolicyManager

#endif

    ......

}

AudioPolicyManagerBase::AudioPolicyManagerBase(

           AudioPolicyClientInterface*clientInterface)

        :mPhoneState(AudioSystem::MODE_NORMAL), mRingerMode(0),

           mMusicStopTime(0),mLimitRingtoneVolume(false)

{

    mpClientInterface = clientInterface;

    // 先把不相关的内容去掉

    ......

  /*

     返回来调用mpClientInterface的openOutput，实际就是AudioPolicyService。

      注意openOutput函数是在AP的创建过程中调用的

  */

   mHardwareOutput =mpClientInterface->openOutput(&outputDesc->mDevice,

                                    &outputDesc->mSamplingRate,

                                   &outputDesc->mFormat,

                                   &outputDesc->mChannels,

                                   &outputDesc->mLatency,

                                    outputDesc->mFlags);

    ......

}

audio_io_handle_tAudioPolicyService::openOutput(uint32_t *pDevices,

                                uint32_t*pSamplingRate,

                                uint32_t*pFormat,

                               uint32_t*pChannels,

                                uint32_t*pLatencyMs,

                               AudioSystem::output_flags flags)

{

  sp<IAudioFlinger>af = AudioSystem::get_audio_flinger();

  //下面会调用AudioFlinger的openOutput，这个时候AF已经启动了

   returnaf->openOutput(pDevices, pSamplingRate, (uint32_t *)pFormat,

                          pChannels, pLatencyMs,flags);

}

int AudioFlinger::openOutput(

uint32_t *pDevices,uint32_t*pSamplingRate,uint32_t *pFormat,

       uint32_t*pChannels,uint32_t *pLatencyMs,uint32_t flags)

{

   ......

  Mutex::Autolock _l(mLock);

   //创建Audio HAL的音频输出对象，和音频输出扯上了关系

   AudioStreamOut *output = mAudioHardware->openOutputStream(*pDevices,

                                                            (int *)&format,

                                                            &channels,

                                                            &samplingRate,

                                                            &status);

   mHardwareStatus = AUDIO_HW_IDLE;

    if(output != 0) {

        if((flags & AudioSystem::OUTPUT_FLAG_DIRECT) ||

           (format != AudioSystem::PCM_16_BIT) ||

           (channels != AudioSystem::CHANNEL_OUT_STEREO)) {

           //如果标志为OUTPUT_FLAG_DIRECT,则创建DirectOutputThread

           thread = new DirectOutputThread(this, output, ++mNextThreadId);

          } else {

         //一般创建的都是MixerThread，注意代表AudioStreamOut对象的output也传进去了

          thread= new MixerThread(this, output, ++mNextThreadId);

        }

        //把新创建的线程加入线程组mPlaybackThreads中保存, mNextThreadId是它的索引号

       mPlaybackThreads.add(mNextThreadId, thread);

       ......

     return mNextThreadId;//返回该线程的索引号

    }

    return0;

}

AudioFlinger::MixerThread::MixerThread(

        constsp<AudioFlinger>& audioFlinger,

        AudioStreamOut*output, // AudioStreamOut为音频输出设备的HAL抽象

        intid)

     :  PlaybackThread(audioFlinger, output, id),mAudioMixer(0)

{

   mType = PlaybackThread::MIXER;

  //混音器对象，这个对象比较复杂，它完成多路音频数据的混合工作

  mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);

}

AudioFlinger::PlaybackThread::PlaybackThread(constsp<AudioFlinger>&

            audioFlinger, AudioStreamOut* output, int id)

        :   ThreadBase(audioFlinger, id),

          mMixBuffer(0),mSuspended(0), mBytesWritten(0),

         mOutput(output), mLastWriteTime(0),mNumWrites(0),

          mNumDelayedWrites(0), mInWrite(false)

{

    //获取音频输出HAL对象的一些信息，包括硬件中音频缓冲区的大小（以帧为单位）

    readOutputParameters();

    mMasterVolume= mAudioFlinger->masterVolume();

    mMasterMute= mAudioFlinger->masterMute();

  //设置不同类型音频流的音量及静音情况

    for(int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++)

    {

        mStreamTypes[stream].volume=

                     mAudioFlinger->streamVolumeInternal(stream);

        mStreamTypes[stream].mute= mAudioFlinger->streamMute(stream);

    }

  //发送一个通知消息给监听者，这部分内容较简单，读者可自行研究

  sendConfigEvent(AudioSystem::OUTPUT_OPENED);

 }

void AudioFlinger::PlaybackThread::onFirstRef()

{

    constsize_t SIZE = 256;

    charbuffer[SIZE];

   snprintf(buffer, SIZE, "Playback Thread %p", this);

   //下面的run就真正创建了线程并开始执行threadLoop

   run(buffer, ANDROID_PRIORITY_URGENT_AUDIO);

}

status_tAudioFlinger::PlaybackThread::Track::start()

{

   status_t status = NO_ERROR;

    sp<ThreadBase>thread = mThread.promote();

  //该Thread是用例中的MixerThread

    if(thread != 0) {

        Mutex::Autolock _l(thread->mLock);

       int state = mState;

        if (mState == PAUSED) {

           mState = TrackBase::RESUMING;

          } else {

           mState = TrackBase::ACTIVE;//设置Track的状态

        }

        PlaybackThread *playbackThread =(PlaybackThread *)thread.get();

        //addTrack_l把这个track加入到mActiveTracks数组中

       playbackThread->addTrack_l(this);

    returnstatus;

}

status_tAudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)

{

   status_t status = ALREADY_EXISTS;

    //①mRetryCount：设置重试次数，kMaxTrackStartupRetries值为50

   track->mRetryCount = kMaxTrackStartupRetries;

   if(mActiveTracks.indexOf(track) < 0) {

      //②mFillingUpStatus：缓冲状态

      track->mFillingUpStatus= Track::FS_FILLING;

      //原来是把调用start的这个track加入到活跃的Track数组中了

     mActiveTracks.add(track);

     status = NO_ERROR;

   }

  //广播一个事件，一定会触发MixerThread线程，通知它有活跃数组加入，需要开工干活

   mWaitWorkCV.broadcast();

    return status;

}

说明：我们在介绍大流程的同时也把一些细节问题指出来，希望这些细节问题能激发读者深入研究的欲望。

bool AudioFlinger::MixerThread::threadLoop()

{

   int16_t* curBuf = mMixBuffer;

   Vector< sp<Track> > tracksToRemove;

   uint32_t mixerStatus = MIXER_IDLE;

    nsecs_tstandbyTime = systemTime();

    ......

    uint32_t sleepTime = idleSleepTime;

    while(!exitPending())

    {

     //① 处理一些请求和通知消息，如之前在构造函数中发出的OUTPUT_OPEN消息等

      processConfigEvents();

       mixerStatus = MIXER_IDLE;

        {// scope for mLock

           Mutex::Autolock _l(mLock);

          //检查配置参数，如有需要则重新设置内部参数值

           if (checkForNewParameters_l()) {

               mixBufferSize = mFrameCount * mFrameSize;

               maxPeriod = seconds(mFrameCount) / mSampleRate * 3;

               ......

           }

          //获得当前的已激活track数组

           const SortedVector< wp<Track> >& activeTracks =mActiveTracks;

             ......

           /*

            ②prepareTracks_l将检查mActiveTracks数组，判断是否有AT的数据需要处理。

               例如有些AudioTrack虽然调用了start，但是没有及时write数据，这时就无须

进行混音工作。我们待会再分析prepareTracks_l函数

          */

           mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);

       }

        //MIXER_TRACKS_READY表示AT已经把数据准备好了

        if(LIKELY(mixerStatus == MIXER_TRACKS_READY)) {

           //③ 由混音对象进行混音工作，混音的结果放在curBuf中

           mAudioMixer->process(curBuf);

           sleepTime = 0;//等待时间设置为零，表示需要马上输出到Audio HAL

           standbyTime = systemTime() + kStandbyTimeInNsecs;

        }

          .......

        if(sleepTime == 0) {

           ......

          //④ 往Audio HAL的OutputStream中write混音后的数据，这是音频数据的最终归宿

           int bytesWritten = (int)mOutput->write(curBuf, mixBufferSize);

           if (bytesWritten < 0) mBytesWritten -= mixBufferSize;

             ......

           mStandby = false;

        }else {

           usleep(sleepTime);

        }

       tracksToRemove.clear();

    }

    if(!mStandby) {

       mOutput->standby();

    }

    returnfalse;

}

uint32_tAudioFlinger::MixerThread::prepareTracks_l(

                         constSortedVector<wp<Track>>& activeTracks,

                         Vector<sp<Track>>*tracksToRemove)

{

   uint32_t mixerStatus = MIXER_IDLE;

    //激活Track的个数

    size_tcount = activeTracks.size();

    floatmasterVolume = mMasterVolume;

   bool  masterMute = mMasterMute;

  //依次查询这些Track的情况

   for(size_t i=0 ; i<count ; i++) {

       sp<Track> t = activeTracks[i].promote();

        if(t == 0) continue;

       Track* const track = t.get();

     //怎么查？通过audio_track_cblk_t对象

       audio_track_cblk_t* cblk = track->cblk();

   /*

      一个混音器可支持32个Track，它内部有一个32元素的数组，name函数返回的就是Track在

      这个数组中的索引。混音器每次通过setActiveTrack设置一个活跃Track，

      后续所有操作都会针对当前设置的这个活跃Track

    */

       mAudioMixer->setActiveTrack(track->name());
       

      //下面这个判断语句决定了什么情况下Track数据可用

     if (cblk->framesReady() &&(track->isReady() || track->isStopped())

             && !track->isPaused()&& !track->isTerminated())

        {

            ......

           /*

            设置活跃Track的数据提供者为Track本身，因为Track从AudioBufferProvider

            派生。混音器工作时，需从Track得到待混音的数据，也就是AT写入的数据由混音

            器取出并消费

         */

          mAudioMixer->setBufferProvider(track);

          //设置对应Track的混音标志

           mAudioMixer->enable(AudioMixer::MIXING);

          ......

           //设置该Track的音量等信息，这在以后的混音操作中会使用

           mAudioMixer->setParameter(param, AudioMixer::VOLUME0, left);

            mAudioMixer->setParameter(param,AudioMixer::VOLUME1, right);

           mAudioMixer->setParameter(

               AudioMixer::TRACK,

               AudioMixer::FORMAT, track->format());

            ......

            mixerStatus = MIXER_TRACKS_READY;

        }else {//如果不满足上面的条件，则走else分支

           if (track->isStopped()) {

               track->reset();//reset会清零读写位置，表示没有可读数据

           }

           //如果处于这三种状态之一，则加入移除队列

           if (track->isTerminated() || track->isStopped()

                    || track->isPaused()) {

               tracksToRemove->add(track);

               mAudioMixer->disable(AudioMixer::MIXING);

           } else {

             //不处于上面三种状态时，表示暂时没有可读数据，则重试mRetryCount次

            if (--(track->mRetryCount) <= 0) {

                 tracksToRemove->add(track);

               } else if (mixerStatus != MIXER_TRACKS_READY) {

                    mixerStatus =MIXER_TRACKS_ENABLED;

               }

             //禁止这个Track的混音

               mAudioMixer->disable(AudioMixer::MIXING);

            ......

         }

        }

    }

    //对那些被移除的Track做最后的处理

   ......

    returnmixerStatus;

}

void AudioMixer::process(void* output)

{

   mState.hook(&mState, output);//hook？这是一个函数指针

}

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;

    //hook初始化的时候为process__nop，这个函数什么都不会做

    mState.hook = process__nop;

    track_t*t = mState.tracks;//track_t是和Track相对应的一个结构

    //最大支持32路混音，也很不错了

    for(int i=0 ; i<32 ; i++) {

        ......

       t->channelCount = 2;

       t->enabled = 0;

       t->format = 16;

        t->buffer.raw = 0;

       t->bufferProvider = 0; // bufferProvider为这一路Track的数据提供者

       t->hook = 0;//每一个Track也有一个hook函数

        ......

    }

   int             mActiveTrack;

   uint32_t        mTrackNames;

    constuint32_t  mSampleRate;

    state_t         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];

  /*

    aligned表示32字节对齐，由于source insight不认识这个标志，导致

    state_t不能被解析。在看代码时，可以注释掉后面的attribute，这样source insight

     就可以识别state_t结构了

 */   

         track_t         tracks[32]; __attribute__((aligned(32)));

    };

mAudioMixer->setBufferProvider(track);

mAudioMixer->enable(AudioMixer::MIXING);//使能混音

status_t AudioMixer::enable(int name)

{

    switch(name) {

       case MIXING: {

           if (mState.tracks[ mActiveTrack ].enabled != 1) {

               mState.tracks[ mActiveTrack ].enabled = 1;

               //注意这个invalidateState调用

               invalidateState(1<<mActiveTrack);

           }

        }break;

       default:

           return NAME_NOT_FOUND;

    }

    returnNO_ERROR;

}

void AudioMixer::invalidateState(uint32_t mask)

 {

    if(mask) {

       mState.needsChanged |= mask;

       mState.hook = process__validate;//将hook设置为process_validate

    }

 }

void AudioMixer::process__validate(state_t*state, void* output)

{

   uint32_t changed = state->needsChanged;

   state->needsChanged = 0;

  uint32_t enabled = 0;

   uint32_t disabled = 0;

    ......

    if(countActiveTracks) {

        if(resampling) {

           ......

         //如果需要重采样，则选择process__genericResampling

           state->hook = process__genericResampling;

        }else {

           ......

           state->hook = process__genericNoResampling;

           if (all16BitsStereoNoResample && !volumeRamp) {

               if (countActiveTracks == 1) {

             //如果只有一个Track，则使用process__OneTrack16BitsStereoNoResampling

                    state->hook =process__OneTrack16BitsStereoNoResampling;

               }

           }

        }

    }

  state->hook(state, output);

  ......

}

说明：在这个数据消费和之前破解AT的过程中所讲的数据生产是对应的，先来提炼AT和AF在生产和消费这两个环节上与CB交互的流程。

voidAudioMixer::process__OneTrack16BitsStereoNoResampling(

        state_t*state, void* output)

{

   //找到被激活的Track，此时只能有一个Track，否则就不会选择这个process函数了

    constint i = 31 - __builtin_clz(state->enabledTracks);

    consttrack_t& t = state->tracks[i];

   AudioBufferProvider::Buffer& b(t.buffer);

    ......

    while(numFrames) {

       b.frameCount = numFrames;

       //BufferProvider就是Track对象，调用它的getNextBuffer获得可读数据缓冲

       t.bufferProvider->getNextBuffer(&b);

       int16_t const *in = b.i16;

       ......

       size_t outFrames = b.frameCount;

         do {//数据处理，也即是混音

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

               in += 2;

               int32_t l = mulRL(1, rl, vrl) >> 12;

               int32_t r = mulRL(0, rl, vrl) >> 12;

              //把数据复制给out缓冲

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

           } while (--outFrames);

        }

       numFrames -= b.frameCount;

       //调用Track的releaseBuffer释放缓冲

       t.bufferProvider->releaseBuffer(&b);

    }

}

status_tAudioFlinger::PlaybackThread::Track::getNextBuffer(

                         AudioBufferProvider::Buffer*buffer)

{

     audio_track_cblk_t*cblk = this->cblk();//通过CB对象完成

    uint32_t framesReady;

    //frameCount为AudioOutput音频输出对象的缓冲区大小

    uint32_t framesReq = buffer->frameCount;

     ......

     //根据CB的读写指针计算有多少帧数据可读

    framesReady = cblk->framesReady();

     if (LIKELY(framesReady)){

       uint32_t s = cblk->server; //当前读位置

        //可读的最大位置，为当前读位置加上frameCount

         uint32_tbufferEnd = cblk->serverBase + cblk->frameCount;

        //AT可以通过setLooping设置播放的起点和终点，如果有终点的话，需要以loopEnd

       //作为数据缓冲的末尾

       bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd :bufferEnd;

        if(framesReq > framesReady) {

         //如果要求的读取帧数大于可读帧数，则只能选择实际可读的帧数

           framesReq = framesReady;

        }

       //如果可读帧数的最后位置超过了AT设置的末端点，则需要重新计算可读帧数

        if(s + framesReq > bufferEnd) {

           framesReq = bufferEnd - s;

        }

        //根据读起始位置得到数据缓冲的起始地址，framesReq参数用来做内部检查，防止出错

        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;

}

void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(

                 AudioBufferProvider::Buffer*buffer)

{

   buffer->raw = 0;

   mFrameCount = buffer->frameCount;//frameCount为getNextBuffer中分配的可读帧数

   step();//调用step函数

   buffer->frameCount = 0;

}

bool AudioFlinger::ThreadBase::TrackBase::step(){

    boolresult;

   audio_track_cblk_t* cblk = this->cblk();

  //调用stepServer更新读位置

    result= cblk->stepServer(mFrameCount);

    if(!result) {

       mFlags |= STEPSERVER_FAILED;

    }

    returnresult;

}

void AudioFlinger::PlaybackThread::Track::stop()

{

   sp<ThreadBase> thread = mThread.promote();

    if(thread != 0) {

       Mutex::Autolock _l(thread->mLock);

       int state = mState;//保存旧的状态

        if(mState > STOPPED) {

           mState = STOPPED;//设置新状态为STOPPED

           PlaybackThread *playbackThread = (PlaybackThread *)thread.get();

           if (playbackThread->mActiveTracks.indexOf(this) < 0) {

               reset();//如果该线程的活跃数组中没有Track，则重置读写位置

            }

       }

       //和APS相关，我们不在这里讨论，它不直接影响AudioFlinger

        if(!isOutputTrack() && (state == ACTIVE || state == RESUMING)) {

           thread->mLock.unlock();

           AudioSystem::stopOutput(thread->id(),

               (AudioSystem::stream_type)mStreamType);

           thread->mLock.lock();

        }

    }

}

if (cblk->framesReady() &&(track->isReady() || track->isStopped())

 && !track->isPaused() &&!track->isTerminated())

说明：在介绍Track和TrackHandle一节中，曾在最后提到了那个野指针问题。相信读者这时候会知道那个问题的答案了，是吗？

AudioFlinger::TrackHandle::~TrackHandle() {

   mTrack->destroy();

}

voidAudioFlinger::PlaybackThread::Track::destroy()

{

   sp<Track> keep(this);

    {

       sp<ThreadBase> thread = mThread.promote();

        if(thread != 0) {

            if (!isOutputTrack()) {

              //和AudioSystem相关，以后再分析

               if (mState == ACTIVE || mState == RESUMING) {

                   AudioSystem::stopOutput(thread->id(),

                          (AudioSystem::stream_type)mStreamType);

               }

                AudioSystem::releaseOutput(thread->id());

           }

           Mutex::Autolock _l(thread->mLock);

           PlaybackThread *playbackThread = (PlaybackThread *)thread.get();

          //调用回放线程对象的destroyTrack_l

           playbackThread->destroyTrack_l(this);

        }

    }

}

voidAudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)

{

   track->mState = TrackBase::TERMINATED;//设置状态为TERMINATED

    if(mActiveTracks.indexOf(track) < 0) {

       mTracks.remove(track);//如果不在mActiveTracks数组中，则把它从mTracks中去掉。

       //由PlaybackThread的子类实现，一般就是回收一些资源等工作

       deleteTrackName_l(track->name());

    }

}

AudioFlinger::ThreadBase::TrackBase::~TrackBase()

{

if (mCblk) {

      //placementnew出来的对象需要显示调用的析构函数

       mCblk->~audio_track_cblk_t();

        if(mClient == NULL) {

           delete mCblk;//先调用析构，再释放内存，这是placement new的用法

        }

    }

   mCblkMemory.clear();

    if(mClient != NULL) {

       Mutex::Autolock _l(mClient->audioFlinger()->mLock);

       mClient.clear();//如果mClient的强弱引用计数都为0，则会导致该Client被delete

    }

}

说明：其实，要找到TrackHandle是什么时候被delete，会更有难度。

uint32_t audio_track_cblk_t::framesAvailable()

{

   Mutex::Autolock _l(lock);

    returnframesAvailable_l();//调用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帧

    }

}

void* audio_track_cblk_t::buffer(uint32_toffset) const

{

   //buffers是数据缓冲的起始位置，offset是计算出来的基于userBase的偏移。

  //通过这种方式巧妙地把数据缓冲当做环形缓冲来处理

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

}

uint32_t audio_track_cblk_t::stepUser(uint32_tframeCount)

{

 /*

   framecount，表示写了多少帧，前面分配了1024帧，但写的数据可以比这个少

    假设这一次写了512帧

  */

   uint32_t u = this->user;//user位置还没更新，此时u=0；

    u +=frameCount;//u更新了，u=512

    ......

/*

   userBase还是初始值0。可惜只写了1024的一半,所以userBase加不了。

   但这句话很重要，还记得前面的buffer调用吗？取数据地址的时候用offset-userBase，

   一旦user位置到达缓冲的尾部，则userBase也会更新，这样offset-userBase的位置就会

   回到缓冲的头部，从头到尾这么反复循环，不就是一个环形缓冲了吗？非常巧妙！

 */

   if (u>= userBase + this->frameCount) {

       userBase += this->frameCount;

    }

   this->user = u;//喔，user位置也更新为512了，但是useBase还是0

    returnu;

}

uint32_t audio_track_cblk_t::framesReady()

{

   uint32_t u = this->user; //u为512

    uint32_ts = 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;

    }

}

bool audio_track_cblk_t::stepServer(uint32_tframeCount)

{

   status_t err;

     err = lock.tryLock();

   uint32_t s = this->server;

    s +=frameCount; //读了512帧了，所以s=512

     ......

   //没有设置循环播放，所以不走这个

    if (s>= loopEnd) {

       s =loopStart;

        if (--loopCount == 0) {

           loopEnd = UINT_MAX;

           loopStart = UINT_MAX;

        }

}

     //和userBase一样的处理

    if (s>= serverBase + this->frameCount) {

       serverBase += this->frameCount;

    }

   this->server = s; //server为512了

   cv.signal(); //读者读完了，触发一个同步信号，因为读者可能在等待可写的数据缓冲

   lock.unlock();

    returntrue;

}

if (u >= userBase + this->frameCount) {

    //u为1024，userBase为0，frameCount为1024

   userBase += this->frameCount;//好，userBase也为1024了

}

uint32_t audio_track_cblk_t::framesAvailable_l()

{

   uint32_t u = this->user; //1024，写者上一次写完了整个1024帧空间

   uint32_t s = this->server;//512，读者当前读到的位置

    if(out) {

       uint32_t limit = (s < loopStart) ? s : loopStart;

       return limit + frameCount - u;//返回512

    }

}

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

//offset是外界传入的基于userBase的一个偏移量，它的值是userBase+512，所以

//offset-userBase将得到从头开始的那段数据空间。真的是一个环形缓冲。

AudioPolicyService::AudioPolicyService()

        :BnAudioPolicyService() ,

//mpPolicyManager是Audio系统中的另一种HAL对象，它的类型是AudioPolicyInterface

        mpPolicyManager(NULL)

{

     char value[PROPERTY_VALUE_MAX];

    //TonePlayback用于播放Tone音，Tone包括按键音等

   mTonePlaybackThread = new AudioCommandThread(String8(""));

   //用于处理控制命令，例如路由切换、音量调节等

   mAudioCommandThread = newAudioCommandThread(String8("ApmCommandThread"));

#if (defined GENERIC_AUDIO) || (definedAUDIO_POLICY_TEST)

    //注意AudioPolicyManagerBase的构造函数，把this传进去了。

     mpPolicyManager = new AudioPolicyManagerBase(this);

#else

...

   //使用硬件厂商实现的AudioPolicyInterface

    mpPolicyManager= createAudioPolicyManager(this);

#endif

  //根据系统属性来判断照相机拍照时是否强制发声。为了防止偷拍，强制按快门的时候必须发出声音。

    property_get("ro.camera.sound.forced",value, "0");

    mpPolicyManager->setSystemProperty("ro.camera.sound.forced",value);

}

class AudioPolicyInterface

{

public:

......

     //设置设备的连接状态，这些设备有耳机、蓝牙等

    virtualstatus_t setDeviceConnectionState(

                         AudioSystem::audio_devicesdevice,

                        AudioSystem::device_connection_state state,

                         const char *device_address) = 0;

    //设置系统Phone状态，这些状态包括通话状态、来电状态等

   virtual void setPhoneState(int state) = 0;

    //设置force_use的config策略，例如通话中强制使用扬声器

   virtualvoid setForceUse(AudioSystem::force_use usage,

                             AudioSystem::forced_config config) = 0;

     /*

        audio_io_handle_t是int类型。这个函数的目的是根据传入的参数类型

       找到合适的输出句柄。这个句柄，在目前的Audio系统代表AF中的某个工作线程。

       还记得创建AudioTrack的时候传入的那个output值吗？它就是通过这个函数得来的。

       关于这个问题，马上会分析到

    */

   virtualaudio_io_handle_t getOutput(

                 AudioSystem::stream_typestream,

                     uint32_t samplingRate = 0,

                     uint32_t format = AudioSystem::FORMAT_DEFAULT,

                     uint32_t channels = 0,

                     AudioSystem::output_flagsflags =

                 AudioSystem::OUTPUT_FLAG_INDIRECT)= 0;

   //在下面这两个函数后会介绍。它们的第二个参数表示使用的音频流类型，

  virtualstatus_t startOutput(audio_io_handle_t output,

                               AudioSystem::stream_type stream) = 0;

  virtual status_t stopOutput(audio_io_handle_toutput,

                            AudioSystem::stream_type stream) = 0;

    ......

    //音量控制：设置不同音频流的音量级别范围，例如MUSIC有15个级别的音量

   virtual void initStreamVolume(AudioSystem::stream_type stream,

                                      intindexMin,

                                      intindexMax) = 0;

    //设置某个音频流类型的音量级，例如觉得music声音太小时，可以调用这个函数提高音量级

   virtualstatus_t setStreamVolumeIndex(AudioSystem::stream_type stream,

                                          int index) = 0;

 }

enum stream_type {

       DEFAULT          =-1,//默认

       VOICE_CALL       = 0,//通话声

       SYSTEM           = 1,//系统声，例如开关机提示

       RING             = 2,//来电铃声

       MUSIC            = 3,//媒体播放声

       ALARM            = 4,//闹钟等的警告声

       NOTIFICATION     = 5,//短信等的提示声

       BLUETOOTH_SCO    = 6,//蓝牙SCO

       ENFORCED_AUDIBLE = 7,//强制发声，照相机的快门声就属于这个类型

       DTMF             = 8,//DTMF,拨号盘的按键声

       TTS              = 9,//文本转语音，Text to Speech

       NUM_STREAM_TYPES

    };

enum audio_mode {

       MODE_INVALID = -2,

       MODE_CURRENT = -1,

       MODE_NORMAL = 0, //正常，既不打电话，也没有来电

       MODE_RINGTONE,//有来电

       MODE_IN_CALL,//通话状态

       NUM_MODES

};

注意：所谓的设备切换，是指诸如扬声器切换到听筒的情况，而前面常提到的音频输出设备，应该指的是DSP。

注意：蓝牙设备实际上会建立两条数据通路：SCO和A2DP。A2DP和高质量立体声有关，且必须由AudioFlinger向它发送数据。所以“音频数据需要单独发送给蓝牙设备”，这个设备实际上是指蓝牙的A2DP设备。蓝牙技术很复杂，有兴趣的读者可以自行研究。

enum forced_config {

       FORCE_NONE,

       FORCE_SPEAKER,  //强制使用扬声器

       FORCE_HEADPHONES,

       FORCE_BT_SCO,

       FORCE_BT_A2DP,

       FORCE_WIRED_ACCESSORY,

       FORCE_BT_CAR_DOCK,

       FORCE_BT_DESK_DOCK,

       NUM_FORCE_CONFIG,

       FORCE_DEFAULT = FORCE_NONE

}

    enumforce_use {

       FOR_COMMUNICATION,//通话情况，注意前缀，是FOR_XXX

       FOR_MEDIA,//听音乐等媒体相关的情况

       FOR_RECORD,

       FOR_DOCK,

       NUM_FORCE_USE

}

virtual void setForceUse(AudioSystem::force_useusage,//什么情况

                          AudioSystem::forced_configconfig //什么设备

                         )= 0;

enum audio_devices {

        //output devices

       DEVICE_OUT_EARPIECE = 0x1,  //听筒

        DEVICE_OUT_SPEAKER = 0x2,   //扬声器

       DEVICE_OUT_WIRED_HEADSET = 0x4,  //耳机

       DEVICE_OUT_WIRED_HEADPHONE = 0x8, //另外一种耳机

       DEVICE_OUT_BLUETOOTH_SCO = 0x10, //蓝牙相关，SCO用于通话的语音传输

       DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,

        DEVICE_OUT_BLUETOOTH_SCO_CARKIT= 0x40,

       DEVICE_OUT_BLUETOOTH_A2DP = 0x80, //蓝牙相关，A2DP用于立体声传输

       DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,

       DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,

       DEVICE_OUT_AUX_DIGITAL = 0x400,

        DEVICE_OUT_DEFAULT= 0x8000,

       ......

}

说明：实际上很多硬件厂商实现的AudioPolicyInterface，基本上是直接使用这个AudioPolicyManagerBase。

AudioPolicyManagerBase::AudioPolicyManagerBase(

                          AudioPolicyClientInterface*clientInterface)

                         :mPhoneState(AudioSystem::MODE_NORMAL),mRingerMode(0),

                          mMusicStopTime(0),mLimitRingtoneVolume(false)

{

   //APS实现了AudioPolicyClientInterface接口

   mpClientInterface= clientInterface;//这个clientInterface就是APS对象

    //清空强制使用配置

    for(int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) {

       mForceUse[i] = AudioSystem::FORCE_NONE;

    }

    //输出设备有听筒和扬声器

   mAvailableOutputDevices = AudioSystem::DEVICE_OUT_EARPIECE |

                       AudioSystem::DEVICE_OUT_SPEAKER;

   //输入设备是内置的麦克（学名叫传声器）

   mAvailableInputDevices = AudioSystem::DEVICE_IN_BUILTIN_MIC;

#ifdef WITH_A2DP //和蓝牙立体声有关。

   mA2dpOutput = 0;

   mDuplicatedOutput = 0;

   mA2dpDeviceAddress = String8("");

#endif

   mScoDeviceAddress = String8(""); //SCO主要用于通话

  /*

    ①创建一个AudioOutputDescriptor对象，这个对象用来记录并维护与

    输出设备（相当于硬件的音频DSP）相关的信息，例如使用该设备的流个数、各个流的音量、

    该设备所支持的采样率、采样精度等。其中，有一个成员mDevice用来表示目前使用的输出设备，

    例如耳机、听筒、扬声器等

 */

   AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();

    outputDesc->mDevice= (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER;

  /*

    ②还记得MixerThread的来历吗？openOutput导致AF创建了一个工作线程。

    该函数返回的是一个工作线程索引号

  */

   mHardwareOutput =mpClientInterface->openOutput(&outputDesc->mDevice,

                                    &outputDesc->mSamplingRate,

                                   &outputDesc->mFormat,

                                   &outputDesc->mChannels,

                                   &outputDesc->mLatency,

                                   outputDesc->mFlags);

     ......

    //AMB维护了一个与设备相关的key/value集合，下面将对应信息加到该集合中。

    addOutput(mHardwareOutput,outputDesc);

    //③设置输出设备，就是设置DSP的数据流到底从什么设备出去，这里设置的是从扬声器出去

     setOutputDevice(mHardwareOutput,

                       (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER,true);

    }

   //④更新不同策略使用的设备

   updateDeviceForStrategy();

}

mHardwareOutput =mpClientInterface->openOutput(......)

注意：使用mA2dpOutput需要蓝牙设备连接上才会有意义。

说明：关于这一点，现在通过setOutputDevice来分析。

void AudioPolicyManagerBase::setOutputDevice(audio_io_handle_toutput,

                                   uint32_tdevice, bool force, int delayMs)

{

    AudioOutputDescriptor*outputDesc = mOutputs.valueFor(output);

    //判断是否是Duplicate输出，和蓝牙A2DP有关，后面再做分析

    if(outputDesc->isDuplicated()) {

       setOutputDevice(outputDesc->mOutput1->mId, device, force,delayMs);

       setOutputDevice(outputDesc->mOutput2->mId, device, force,delayMs);

       return;

  }

 // 初始设置的输出设备为听筒和扬声器

   uint32_tprevDevice = (uint32_t)outputDesc->device();

   if ((device == 0 || device == prevDevice)&& !force) {

       return;

    }

  //现在设置新的输出设备为扬声器，注意这是软件层面上的设置

  outputDesc->mDevice = device;

     ......

  /*

    还需要硬件也做相应设置，主要是告诉DSP把它的输出切换到某个设备上，根据之前的分析，

   这个请求要发送到AF中的MixerThread上，因为只有它拥有代表输出设备的AudioStreamOut

对象

 */

   AudioParameter param = AudioParameter();

    param.addInt(String8(AudioParameter::keyRouting),(int)device);

 /*

  上面的配置参数将投递到APS的消息队列，而APS中创建的AudioCommandThread

  会取出这个配置参数，再投递给AF中对应的MixerThread，最终由MixerThread处理。

  这个流程，将在耳机插拔事件处理中进行分析

*/

   mpClientInterface->setParameters(mHardwareOutput,

                                           param.toString(),delayMs);

   ......

}

voidAudioPolicyManagerBase::updateDeviceForStrategy()

{

    for(int i = 0; i < NUM_STRATEGIES; i++) {

       mDeviceForStrategy[i] =

                            getDeviceForStrategy((routing_strategy)i,false);

    }

}

//routing_strategy:路由策略

enum routing_strategy {

           STRATEGY_MEDIA, 

           STRATEGY_PHONE,

           STRATEGY_SONIFICATION,

           STRATEGY_DTMF,

           NUM_STRATEGIES

        }

AudioPolicyManagerBase::getStrategy(AudioSystem::stream_typestream)

{

    switch(stream) {

    caseAudioSystem::VOICE_CALL:

    caseAudioSystem::BLUETOOTH_SCO:

        return STRATEGY_PHONE; //PHONE路由策略

    caseAudioSystem::RING:

    caseAudioSystem::NOTIFICATION:

    caseAudioSystem::ALARM:

    caseAudioSystem::ENFORCED_AUDIBLE:

       return STRATEGY_SONIFICATION; //SONIFICATION路由策略

    caseAudioSystem::DTMF:

       return STRATEGY_DTMF;  //DTMF路由策略

   default:

       LOGE("unknown stream type");

    caseAudioSystem::SYSTEM:

    caseAudioSystem::TTS:

    caseAudioSystem::MUSIC:

       return STRATEGY_MEDIA;//media 路由策略

    }

}

status_t AudioTrack::set(int streamType,uint32_tsampleRate,int format,

                          int channels,intframeCount,uint32_t flags,

                          callback_t cbf,void*user,int notificationFrames,

                          constsp<IMemory>& sharedBuffer, bool threadCanCallJava)

{

......

   //得到AF中一个工作线程的索引号

     audio_io_handle_toutput = AudioSystem::getOutput(

                                   (AudioSystem::stream_type)streamType,

                                   sampleRate,format, channels,

                                    (AudioSystem::output_flags)flags);

   ......

//创建Track，最终会调到AF的createTrack

status_t status = createTrack(streamType,sampleRate, format, channelCount,

                                  frameCount,flags, sharedBuffer, output);

audio_io_handle_tAudioSystem::getOutput(stream_type stream,

                                    uint32_tsamplingRate,

                                    uint32_tformat,

                                    uint32_tchannels,

                                    output_flagsflags)

{

   audio_io_handle_t output = 0;

    ......

    if(output == 0) {

       const sp<IAudioPolicyService>& aps =

                                     AudioSystem::get_audio_policy_service();

        if(aps == 0) return 0;

     //调用AP的getOutput函数

       output = aps->getOutput(stream, samplingRate, format, channels,flags);

        if((flags & AudioSystem::OUTPUT_FLAG_DIRECT) == 0) {

           Mutex::Autolock _l(gLock);

         //把这个stream和output的对应关系保存到map中

           AudioSystem::gStreamOutputMap.add(stream, output);

        }

    }

    returnoutput;

}

audio_io_handle_t AudioPolicyService::getOutput(

                          AudioSystem::stream_typestream, uint32_t samplingRate,

                          uint32_tformat,uint32_t channels,

                          AudioSystem::output_flagsflags)

{

   //和硬件厂商的实现相关，所以交给AudioPolicyInterface处理

   //这里将由AudioPolicyManagerBase处理

    Mutex::Autolock _l(mLock);

    returnmpPolicyManager->getOutput(stream, samplingRate, format, channels,

                                             flags);

}

audio_io_handle_tAudioPolicyManagerBase::getOutput(

                     AudioSystem::stream_typestream, uint32_t samplingRate,

                     uint32_t format,uint32_tchannels,

                     AudioSystem::output_flagsflags)

{

   audio_io_handle_t output = 0;

    uint32_tlatency = 0;

   //根据流类型得到对应的路由策略，这个我们已经见过了，MUSIC类型返回MUSIC策略

   routing_strategystrategy = getStrategy((AudioSystem::stream_type)stream);

  //根据策略得到使用这个策略的输出设备（指扬声器之类的），以后再看这个函数

    uint32_tdevice = getDeviceForStrategy(strategy);

......

   //看这个设备是不是与蓝牙的A2DP相关

   uint32_ta2dpDevice = device & AudioSystem::DEVICE_OUT_ALL_A2DP;

   if(AudioSystem::popCount((AudioSystem::audio_devices)device) == 2) {

#ifdef WITH_A2DP

     //对于有A2DP支持，a2dpUsedForSonification函数直接返回true

  if (a2dpUsedForSonification() &&a2dpDevice != 0) {

      //和DuplicatingThread相关，以后再看

        output = mDuplicatedOutput;

 } else

#endif

       {

        output = mHardwareOutput; //使用非蓝牙的混音输出线程

        }

    } else{

#ifdef WITH_A2DP

        if(a2dpDevice != 0) {

           //使用蓝牙的混音输出线程

           output = mA2dpOutput;

        }else

#endif

        {

          output = mHardwareOutput;

        }

    }

  returnoutput;

}

status_tAudioFlinger::PlaybackThread::Track::start()

{

   status_t status = NO_ERROR;

    sp<ThreadBase> thread = mThread.promote();

     ......

        if(!isOutputTrack() && state != ACTIVE && state != RESUMING) {

           thread->mLock.unlock();

          //调用AudioSystem的startOutput

           status = AudioSystem::startOutput(thread->id(),

                                  (AudioSystem::stream_type)mStreamType);

            thread->mLock.lock();

        }

      PlaybackThread *playbackThread = (PlaybackThread *)thread.get();

      playbackThread->addTrack_l(this);//把这个Track加入到活跃Track数组中

    returnstatus;

}

status_tAudioSystem::startOutput(audio_io_handle_t output,

                                         AudioSystem::stream_typestream)

{

   constsp<IAudioPolicyService>& aps =

                                       AudioSystem::get_audio_policy_service();

  if (aps== 0) return PERMISSION_DENIED;

    //调用AP的startOutput，最终由AMB完成实际功能

    returnaps->startOutput(output, stream);

}

status_tAudioPolicyManagerBase::startOutput(audio_io_handle_t output,

                                         AudioSystem::stream_typestream)

{

    //根据output找到对应的AudioOutputDescriptor

   ssize_t index = mOutputs.indexOfKey(output);

    AudioOutputDescriptor*outputDesc = mOutputs.valueAt(index);

   //找到对应流使用的路由策略

   routing_strategy strategy =getStrategy((AudioSystem::stream_type)stream);

   //增加outputDesc中该流的使用计数，1表示增加1

    outputDesc->changeRefCount(stream, 1);

//getNewDevice将得到一个设备，setOutputDevice将使用这个设备进行路由切换。

//至于setOutputDevice，我们在分析耳机插入事件时再来讲解

   setOutputDevice(output, getNewDevice(output));

    //设置音量，读者可自行分析

    checkAndSetVolume(stream,mStreams[stream].mIndexCur, output,

                         outputDesc->device());

  returnNO_ERROR;

}

uint32_tAudioPolicyManagerBase::getNewDevice(audio_io_handle_t output,

                                                        bool fromCache)

{

   uint32_t device = 0;

   AudioOutputDescriptor*outputDesc = mOutputs.valueFor(output);

  /*

    isUsedByStrategy判断某个策略是否正在被使用，之前曾通过changeRefCount为

    MUSIC流使用计数增加了1，所以使用MUSIC策略的个数至少为1，这表明，此设备正在使用该策略。

    一旦得到当前outputDesc使用的策略，便可根据该策略找到对应的设备。

    注意if和else的顺序，它代表了系统优先使用的策略,以第一个判断为例，

    假设系统已经插上耳机，并且处于通话状态时，而且强制使用了扬声器，那么声音都从扬声器出。

    这时，如果想听音乐的话，则应首先使用STRATEGY_PHONE的对应设备，此时就是扬声器。

    所以音乐将从扬声器出来，而不是耳机。上面仅是举例，具体的情况还要综合考虑Audio

    系统中的其他信息。另外如果fromCache为true，将直接从内部保存的旧信息中得到设备，

    关于这个问题，在后面的耳机插入事件处理中再做分析

   */

    if(mPhoneState == AudioSystem::MODE_IN_CALL ||

       outputDesc->isUsedByStrategy(STRATEGY_PHONE)) {

       device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);

    } elseif (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION)) {

       device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);

    } elseif (outputDesc->isUsedByStrategy(STRATEGY_MEDIA)) {

       device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);

    } elseif (outputDesc->isUsedByStrategy(STRATEGY_DTMF)) {

       device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);

    }

    returndevice;

}

提醒：读者可自行分析stop的处理方式，基本上是start的逆向处理过程。

private class AudioServiceBroadcastReceiverextends BroadcastReceiver{

@Override

       public void onReceive(Context context, Intent intent) {

           String action = intent.getAction();

       ......

                  //如果该事件是耳机插拔事件

        elseif (action.equals(Intent.ACTION_HEADSET_PLUG)) {

                //取得耳机的状态

               int state = intent.getIntExtra("state", 0);

               int microphone =intent.getIntExtra("microphone", 0);

               if (microphone != 0) {

                 //察看已连接设备是不是已经有了耳机，耳机的设备号为0x4，

                //这个和AudioSystem.h定义的设备号是一致的

                    boolean isConnected =mConnectedDevices.containsKey(

                              AudioSystem.DEVICE_OUT_WIRED_HEADSET);

                    //如果之前有耳机而现在没有，则认为是耳机拔出事件

                    if (state == 0 &&isConnected) {

                        //设置Audio系统的设备连接状态，耳机为Unavailable

                        AudioSystem.setDeviceConnectionState(

                                AudioSystem.DEVICE_OUT_WIRED_HEADSET,

                               AudioSystem.DEVICE_STATE_UNAVAILABLE,

                                "");

               //从已连接设备中去掉耳机设备

               mConnectedDevices.remove(AudioSystem.DEVICE_OUT_WIRED_HEADSET);

         } //如果state为1，并且之前没有耳机连接,则处理这个耳机插入事件

          else if (state == 1 && !isConnected){

             //设置Audio系统的设备连接状态，耳机为Available

                    AudioSystem.setDeviceConnectionState(

                        AudioSystem.DEVICE_OUT_WIRED_HEADSET,

                        AudioSystem.DEVICE_STATE_AVAILABLE,

                        "");

             //已连接设备中增加耳机  

             mConnectedDevices.put(

                         new Integer(AudioSystem.DEVICE_OUT_WIRED_HEADSET),

                         "");

                    }

               }

......

  publicstatic native int setDeviceConnectionState(int device, int state,

                                                             String device_address);

//注意我们传入的参数，device为0X4表示耳机，state为1，device_address为””

static int android_media_AudioSystem_setDeviceConnectionState(

                                      JNIEnv*env, jobject thiz, jint

                                      device,jint state, jstring device_address)

{

    constchar *c_address = env->GetStringUTFChars(device_address, NULL);

    intstatus = check_AudioSystem_Command(

    //调用Native AudioSystem的setDeviceConnectionState

    AudioSystem::setDeviceConnectionState(

                 static_cast<AudioSystem::audio_devices>(device),

                 static_cast<AudioSystem::device_connection_state>(state),

                c_address));

   env->ReleaseStringUTFChars(device_address, c_address);

    returnstatus;

}

status_tAudioSystem::setDeviceConnectionState(audio_devices device,

                                                       device_connection_state state,

                                                       const char *device_address)

{

    constsp<IAudioPolicyService>& aps =

                                       AudioSystem::get_audio_policy_service();

    if(aps == 0) return PERMISSION_DENIED;

    //转到AP去，最终由AMB处理

    returnaps->setDeviceConnectionState(device, state, device_address);

}

status_tAudioPolicyManagerBase::setDeviceConnectionState(

                  AudioSystem::audio_devicesdevice,

                  AudioSystem::device_connection_statestate,

                  const char *device_address)

{

    //一次只能设置一个设备

    if(AudioSystem::popCount(device) != 1) return BAD_VALUE;

     ......

     //根据设备号判断是不是输出设备，耳机肯定属于输出设备

   if(AudioSystem::isOutputDevice(device)) {

      switch (state)

        {

       case AudioSystem::DEVICE_STATE_AVAILABLE:

          //处理耳机插入事件，mAvailableOutputDevices保存已连接的设备

           //这个耳机是刚连上的，所以不走下面if分支

           if (mAvailableOutputDevices & device) {

               //启用过了，就不再启用了。

               return INVALID_OPERATION;

           }

           //现在已连接设备中多了一个耳机

           mAvailableOutputDevices |= device;

             ....

         }

        //① getNewDevice之前已分析过了，这次再看

         uint32_t newDevice =getNewDevice(mHardwareOutput, false);

         //②更新各种策略使用的设备

          updateDeviceForStrategy();

         //③设置新的输出设备

          setOutputDevice(mHardwareOutput,newDevice);

     ......

}

uint32_tAudioPolicyManagerBase::getNewDevice(audio_io_handle_t output,

                                                       bool fromCache)

{  //注意我们传入的参数，output为mHardwardOutput,fromCache为false

    uint32_tdevice = 0;

    //根据output找到对应的AudioOutputDescriptor，这个对象保存了一些信息

   AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);

    if(mPhoneState == AudioSystem::MODE_IN_CALL ||

         outputDesc->isUsedByStrategy(STRATEGY_PHONE))

    {

       device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);

    }

     elseif (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION))

    {

       device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);

     }

     elseif (outputDesc->isUsedByStrategy(STRATEGY_MEDIA))

    {

         //应用场景是正在听歌，所以会走这个分支

        device= getDeviceForStrategy(STRATEGY_MEDIA, fromCache);

     }

    elseif (outputDesc->isUsedByStrategy(STRATEGY_DTMF))

    {

       device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);

     }

    return device;

}

uint32_tAudioPolicyManagerBase::getDeviceForStrategy(

                                       routing_strategystrategy, bool fromCache)

{

   uint32_t device = 0;

    if (fromCache){//如果为true，则直接取之前的旧值

      return mDeviceForStrategy[strategy];

    }

  //如果fromCache为false，则需要重新计算策略所对应的设备

    switch(strategy) {

    caseSTRATEGY_DTMF://先处理DTMF策略的情况

        if(mPhoneState != AudioSystem::MODE_IN_CALL) {

          //如果不处于电话状态，则DTMF的策略和MEDIA策略对应同一个设备

           device = getDeviceForStrategy(STRATEGY_MEDIA, false);

           break;

        }

         //如果处于电话状态，则DTMF策略和PHONE策略用同一个设备

    caseSTRATEGY_PHONE:

         //是PHONE策略的时候，先要考虑是不是用户强制使用了某个设备，例如强制使用扬声器

       switch (mForceUse[AudioSystem::FOR_COMMUNICATION]) {

         ......

       case AudioSystem::FORCE_SPEAKER:

        ...... //如果没有蓝牙，则选择扬声器

           device = mAvailableOutputDevices &

                                           AudioSystem::DEVICE_OUT_SPEAKER;

           break;

        }

    break;

    caseSTRATEGY_SONIFICATION://SONIFICATION策略

        if(mPhoneState == AudioSystem::MODE_IN_CALL) {

           /*

             如果处于来电状态，则和PHONE策略用同一个设备。例如通话过程中我们强制使用

             扬声器，那么这个时候按拨号键，则按键声也会从扬声器出来

           */

           device = getDeviceForStrategy(STRATEGY_PHONE, false);

           break;

        }

       device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER;

        //如果不处于电话状态，则SONIFICATION和MEDIA策略用同一个设备

case STRATEGY_MEDIA: {

       //AUX_DIGITAL值为0x400，耳机不满足该条件

       uint32_t device2 = mAvailableOutputDevices &

                                   AudioSystem::DEVICE_OUT_AUX_DIGITAL;

        if(device2 == 0) {

          //也不满足WIRED_HEADPHONE条件

           device2 = mAvailableOutputDevices &

                                   AudioSystem::DEVICE_OUT_WIRED_HEADPHONE;

        }

        if(device2 == 0) {

           //满足这个条件，所以device2为0x4，WIRED_HEADSET

           device2 = mAvailableOutputDevices &

                                      AudioSystem::DEVICE_OUT_WIRED_HEADSET;

        }

       if(device2 == 0) {

           device2 = mAvailableOutputDevices &

                                      AudioSystem::DEVICE_OUT_SPEAKER;

        }

      device |= device2; //最终device为0x4，WIRED_HEADSET

     }break;

   default:

      break;

    }

    returndevice;

}

voidAudioPolicyManagerBase::updateDeviceForStrategy()

{

    for(int i = 0; i < NUM_STRATEGIES; i++) {

  //重新计算每种策略使用的设备，并保存到mDeviceForStrategy中，起到了cache的作用

 mDeviceForStrategy[i] =

                              getDeviceForStrategy((routing_strategy)i,false);

    }

}

updateDevicdForStrategy();//先更新策略

//使用cache中的设备，节省一次重新计算                        

uint32_t newDevice =getNewDevice(mHardwareOutput, true);

void AudioPolicyManagerBase::setOutputDevice(audio_io_handle_toutput,

                                       uint32_t device,bool force, int delayMs)

{

    ......

   //把这个请求要发送到output对应的AF工作线程中

     AudioParameterparam = AudioParameter();

   //参数是key/vlaue键值对的格式

    param.addInt(String8(AudioParameter::keyRouting),(int)device);

   //mpClientInterface是AP对象，由它处理

    mpClientInterface->setParameters(mHardwareOutput,

                                            param.toString(),delayMs);

   //设置音量，不做讨论，读者可自行分析

   applyStreamVolumes(output, device, delayMs);

 }

voidAudioPolicyService::setParameters(audio_io_handle_t ioHandle,

                              constString8& keyValuePairs, int delayMs)

{

    //把这个请求加入到AudioCommandThread处理

    mAudioCommandThread->parametersCommand((int)ioHandle,

                                                 keyValuePairs, delayMs);

}

说明：这种通过一个队列来协调两个线程的方法，在多线程编程中非常常见，它也属于生产者/消费者模型。

boolAudioPolicyService::AudioCommandThread::threadLoop()

{

    nsecs_twaitTime = INT64_MAX;

   mLock.lock();

    while(!exitPending())

    {

       while(!mAudioCommands.isEmpty()) {

           nsecs_t curTime = systemTime();

           if (mAudioCommands[0]->mTime <= curTime) {

               AudioCommand *command = mAudioCommands[0];

               mAudioCommands.removeAt(0);

               mLastCommand = *command;

               switch (command->mCommand) {

               case START_TONE:

                   ......

               case STOP_TONE:

                   ......  //TONE处理

                    mLock.lock();

                    }break;

               case SET_VOLUME: {

                    //设置音量

                    delete data;

                    }break;

               case SET_PARAMETERS: {

                    //处理路由设置请求

                     ParametersData *data =(ParametersData *)command->mParam;

                    //转到AudioSystem处理，mIO的值为mHardwareOutput

                     command->mStatus =AudioSystem::setParameters(

                                          data->mIO,

                                         data->mKeyValuePairs);

                     if(command->mWaitStatus) {

                        command->mCond.signal();

                        mWaitWorkCV.wait(mLock);

                     }

                     delete data;

                     }break;

               ......

               default:

               }

}

status_tAudioSystem::setParameters(audio_io_handle_t ioHandle,

                                           constString8& keyValuePairs)

{

     constsp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();

    //果然是交给AF处理，ioHandle看来一定就是工作线程索引号了

    returnaf->setParameters(ioHandle, keyValuePairs);

}

status_t AudioFlinger::setParameters(intioHandle,

                                   constString8& keyValuePairs)

{

   status_t result;

    // ioHandle == 0 表示和混音线程无关，需要直接设置到HAL对象中。

    if(ioHandle == 0) {

       AutoMutex lock(mHardwareLock);

       mHardwareStatus = AUDIO_SET_PARAMETER;

       //调用AudioHardwareInterface的参数设置接口

       result = mAudioHardware->setParameters(keyValuePairs);

       mHardwareStatus = AUDIO_HW_IDLE;

       return result;

    }

    sp<ThreadBase> thread;

    {

       Mutex::Autolock _l(mLock);

       //根据索引号找到对应混音线程。

       thread = checkPlaybackThread_l(ioHandle);

      }

      //我们只有一个MixerThread,交给它处理，这又是一个命令处理队列

     result = thread->setParameters(keyValuePairs);

      returnresult;

    }

    returnBAD_VALUE;

}

bool AudioFlinger::MixerThread::threadLoop()

{

    ....

    while(!exitPending())

    {

       processConfigEvents();

       mixerStatus = MIXER_IDLE;

        {// scope for mLock

           Mutex::Autolock _l(mLock);

          // checkForNewParameters_l最有嫌疑

           if (checkForNewParameters_l()) {

                ...

           }

      ......//其他处理

}

boolAudioFlinger::MixerThread::checkForNewParameters_l()

{

    boolreconfig = false;

    while(!mNewParameters.isEmpty()) {

       status_t status = NO_ERROR;

       String8 keyValuePair = mNewParameters[0];

       AudioParameter param = AudioParameter(keyValuePair);

       int value;

       ......

      //路由设置需要硬件参与，所以直接交给代表音频输出设备的HAL对象处理

      status = mOutput->setParameters(keyValuePair);

      return reconfig;

}

status_tAudioHardware::AudioStreamOutMSM72xx::setParameters(

const String8& keyValuePairs)

{

   AudioParameter param = AudioParameter(keyValuePairs);

   String8 key = String8(AudioParameter::keyRouting);

    status_tstatus = NO_ERROR;

    intdevice;

    if(param.getInt(key, device) == NO_ERROR) {

       mDevices = device;

        //调用doRouting，mHardware就是AudioHardware对象

       status = mHardware->doRouting();

       param.remove(key);

    }

......

    returnstatus;

}

status_t AudioHardware::doRouting()

{

   Mutex::Autolock lock(mLock);

   uint32_t outputDevices = mOutput->devices();

   status_t ret = NO_ERROR;

    intsndDevice = -1;

      ......

      //做一些判断，最终由doAudioRouteOrMute处理

     if((vr_mode_change) || (sndDevice != -1 && sndDevice != mCurSndDevice)) {

       ret = doAudioRouteOrMute(sndDevice);

       mCurSndDevice = sndDevice;

      }

    returnret;

}

status_t AudioHardware::doAudioRouteOrMute(uint32_tdevice)

{

   uint32_t rx_acdb_id = 0;

   uint32_t tx_acdb_id = 0;

   //只看看就行，对应硬件相关的代码，咱们就是打打酱油

   returndo_route_audio_dev_ctrl(device,

   mMode== AudioSystem::MODE_IN_CALL, rx_acdb_id, tx_acdb_id);

}

static status_t do_route_audio_dev_ctrl(uint32_tdevice, bool inCall,

uint32_t rx_acdb_id, uint32_t tx_acdb_id)

{

   uint32_t out_device = 0, mic_device = 0;

   uint32_t path[2];

    int fd= 0;

  //打开音频控制设备

   fd =open("/dev/msm_audio_ctl", O_RDWR);

   path[0]= out_device;

   path[1]= rx_acdb_id;

    //通过ioctl切换设备，一般系统调用都是返回-1表示出错，这里返回0表示出错

    if(ioctl(fd, AUDIO_SWITCH_DEVICE, &path)) {

      close(fd);

      return -1;

    }

......

}

status_t AudioPolicyManagerBase::setDeviceConnectionState(

                     AudioSystem::audio_devicesdevice,

                    AudioSystem::device_connection_state state,

                     const char *device_address)

{

       ......

        switch (state)

        {

         case AudioSystem::DEVICE_STATE_AVAILABLE:

           mAvailableOutputDevices |= device;

#ifdef WITH_A2DP

           if (AudioSystem::isA2dpDevice(device)) {

                //专门处理A2DP设备的连接

               status_t status = handleA2dpConnection(device, device_address);

         }

#endif

          ......

status_tAudioPolicyManagerBase::handleA2dpConnection(

                                        AudioSystem::audio_devicesdevice,

                                       const char*device_address)

{

   AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();

    outputDesc->mDevice= device;

    //先为mA2dpOutput创建一个MixerThread，这个和mHardwareOutput一样

   mA2dpOutput =mpClientInterface->openOutput(&outputDesc->mDevice,

                                           &outputDesc->mSamplingRate,

                                           &outputDesc->mFormat,

                                            &outputDesc->mChannels,

                                           &outputDesc->mLatency,

                                           outputDesc->mFlags);

if (mA2dpOutput) {

 /*

   a2dpUsedForSonification永远返回true，表示属于SONIFCATION策略的音频流声音需要

同时从蓝牙和DSP中传出。属于SONIFCATION策略的音频流类型可查看前面关于getStrategy的

分析，来电铃声、短信通知等属于这一类

  */

        if(a2dpUsedForSonification()) {

          /*

           创建一个DuplicateOutput，注意它的参数,第一个是蓝牙MixerThread

           第二个是DSPMixerThread

         */

           mDuplicatedOutput = mpClientInterface->openDuplicateOutput(

                                                       mA2dpOutput, mHardwareOutput);

        }

        if(mDuplicatedOutput != 0 ||

           !a2dpUsedForSonification()) {

           if (a2dpUsedForSonification()) {

                //创建一个AudioOutputDescriptor对象

                AudioOutputDescriptor *dupOutputDesc = new

                                                   AudioOutputDescriptor();

               dupOutputDesc->mOutput1 = mOutputs.valueFor(mHardwareOutput);

               dupOutputDesc->mOutput2 = mOutputs.valueFor(mA2dpOutput);

               ......

               //保存mDuplicatedOutput和dupOutputDesc键值对

               addOutput(mDuplicatedOutput, dupOutputDesc);

               ......

           }

        }

}

......

int AudioFlinger::openDuplicateOutput(intoutput1, int output2)

{

    Mutex::Autolock_l(mLock);

    //output1对应蓝牙的MixerThread

    MixerThread*thread1 = checkMixerThread_l(output1);

   //output2对应DSP的MixerThread

   MixerThread *thread2 = checkMixerThread_l(output2);

    //①创建DuplicatingThread，注意它第二个参数使用的，是代表蓝牙的MixerThread

    DuplicatingThread *thread = new DuplicatingThread(this,

                                                     thread1,++mNextThreadId);

    //②加入代表DSP的MixerThread

   thread->addOutputTrack(thread2);

   mPlaybackThreads.add(mNextThreadId, thread);

    returnmNextThreadId;//返回DuplicatingThread的索引

}

AudioFlinger::DuplicatingThread::DuplicatingThread(constsp<AudioFlinger>&

                audioFlinger, AudioFlinger::MixerThread*mainThread,int id)

               :   MixerThread(audioFlinger,mainThread->getOutput(), id),

                    mWaitTimeMs(UINT_MAX)

{

//DT是MT的派生类，所以先要完成基类的构造，还记得MT的构造吗？它会创建一个AudioMixer对象

  mType =PlaybackThread::DUPLICATING;

//把代表DSP的MT加入进来，咱们看看

   addOutputTrack(mainThread);

}

voidAudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)

{

   intframeCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate();

   //构造一个OutputTrack，它的第一个参数是MT

   OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread,

                                           this, mSampleRate, mFormat,

                                           mChannelCount,frameCount);

    if(outputTrack->cblk() != NULL) {

       thread->setStreamVolume(AudioSystem::NUM_STREAM_TYPES, 1.0f);

        //把这个outputTrack加入到mOutputTracks数组保存

       mOutputTracks.add(outputTrack);

       updateWaitTime();

    }

}

DuplicatingThread *thread = newDuplicatingThread(this,

                                                           thread1,++mNextThreadId);

thread->addOutputTrack(thread2);

AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(

        const wp<ThreadBase>& thread, DuplicatingThread*sourceThread,

       uint32_t sampleRate, int format,int channelCount,int frameCount)

        :Track(thread,NULL, AudioSystem::NUM_STREAM_TYPES, sampleRate,

              format, channelCount, frameCount, NULL),//最后这个参数为NULL

         mActive(false),mSourceThread(sourceThread)

{

     /*

      OutputTrack从Track派生，所以需要先调用基类的构造，还记得Track构造函数

       中的事情吗？它会创建一块内存，至于是不是共享内存，由Track构造函数的最后一个参数决定。

        如果该值为NULL，表示没有客户端参与，则会在本进程内创建一块内存，这块内存的结构如

        图7-4所示，前边为CB对象，后边为数据缓冲

     */

    //下面的这个thread对象为MT

   PlaybackThread *playbackThread = (PlaybackThread *)thread.unsafe_get();

    if(mCblk != NULL) {

       mCblk->out = 1;//表示DT将往MT中写数据

       //和前面所分析的AT、AF中的处理何其相似！

       mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);

       mCblk->volume[0] = mCblk->volume[1] = 0x1000;

       mOutBuffer.frameCount = 0;

       //把这个Track加到MT的Track中

       playbackThread->mTracks.add(this);

}

boolAudioFlinger::DuplicatingThread::threadLoop()

{

   int16_t* curBuf = mMixBuffer;

   Vector< sp<Track> > tracksToRemove;

   uint32_t mixerStatus = MIXER_IDLE;

   nsecs_t standbyTime = systemTime();

    size_tmixBufferSize = mFrameCount*mFrameSize;

   SortedVector< sp<OutputTrack> > outputTracks;

    while(!exitPending())

    {

       processConfigEvents();

       mixerStatus = MIXER_IDLE;

        {

              ......

           //处理配置请求，和MT处理一样

           const SortedVector< wp<Track> >& activeTracks =mActiveTracks;

           for (size_t i = 0; i < mOutputTracks.size(); i++) {

               outputTracks.add(mOutputTracks[i]);

           }

         //如果AT的Track停止了，则需要停止和MT共享的OutputTrack

        ifUNLIKELY((!activeTracks.size() && systemTime() > standbyTime)

               || mSuspended) {

               if (!mStandby) {

                    for (size_t i = 0; i <outputTracks.size(); i++) {

                       outputTracks[i]->stop();

                    }

                   mStandby = true;

                    mBytesWritten = 0;

               }

             ......

           //DT从MT派生，天然具有混音的功能，所以这部分功能和MT一致

           mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);

        }

        if(LIKELY(mixerStatus == MIXER_TRACKS_READY)) {

            //outputsReady将检查OutputTracks对应的MT状态

           if (outputsReady(outputTracks)) {

               mAudioMixer->process(curBuf);//使用AudioMixer对象混音

           } else {

               memset(curBuf, 0, mixBufferSize);

           }

           sleepTime = 0;

           writeFrames = mFrameCount;

        }

              ......

           if (sleepTime == 0) {

               standbyTime = systemTime() +kStandbyTimeInNsecs;

           for (size_t i = 0; i < outputTracks.size(); i++) {

               //将混音后的数据写到outputTrack中

               outputTracks[i]->write(curBuf, writeFrames);

           }

           mStandby = false;

           mBytesWritten += mixBufferSize;

        }else {

           usleep(sleepTime);

        }

       tracksToRemove.clear();

       outputTracks.clear();

    }

    returnfalse;

}

boolAudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data,

                                                                uint32_t frames)

{

   //注意，此处的OutputTrack是DT和MT共享的

    Buffer *pInBuffer;

    BufferinBuffer;

   uint32_t channels = mCblk->channels;

    booloutputBufferFull = false;

   inBuffer.frameCount = frames;

   inBuffer.i16 = data;

   uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();

  if(!mActive && frames != 0) {

      //如果此Track没有活跃，则调用start激活

       start();

        ......

    }

     /*

       现在，AF中的数据传递有三个线程：一个DT，两个MT。MT作为DT的二级消费者，

       可能由于某种原因来不及消费数据，所以DT中提供了一个缓冲队列mBufferQueue，

       把MT来不及消费的数据保存在这个缓冲队列中。注意这个缓冲队列容纳的临时缓冲

       个数是有限制的，其限制值由kMaxOverFlowBuffers控制，初始化为10个

   */

    while(waitTimeLeftMs) {

        //先消耗保存在缓冲队列的数据

        if(mBufferQueue.size()) {

           pInBuffer = mBufferQueue.itemAt(0);

        }else {

           pInBuffer = &inBuffer;

        }

        ......

       //获取可写缓冲，下面这句代码是否和AT中对应的代码很相似？

       if(obtainBuffer(&mOutBuffer, waitTimeLeftMs) ==

                              (status_t)AudioTrack::NO_MORE_BUFFERS){

              ......

               break;

         }

        uint32_toutFrames = pInBuffer->frameCount > mOutBuffer.frameCount ?

                                     mOutBuffer.frameCount: pInBuffer->frameCount;

        //将数据拷贝到DT和MT共享的那块缓冲中去

       memcpy(mOutBuffer.raw, pInBuffer->raw,

                outFrames * channels * sizeof(int16_t));

        //更新写位置

       mCblk->stepUser(outFrames);

        pInBuffer->frameCount-= outFrames;

       pInBuffer->i16 += outFrames * channels;

       mOutBuffer.frameCount -= outFrames;

       mOutBuffer.i16 += outFrames * channels;

        ......

     }//while 结束

       if(inBuffer.frameCount) {

       sp<ThreadBase> thread = mThread.promote();

        if(thread != 0 && !thread->standby()) {

           if (mBufferQueue.size() < kMaxOverFlowBuffers) {

               pInBuffer = new Buffer;

               pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channels];

               pInBuffer->frameCount = inBuffer.frameCount;

               pInBuffer->i16 = pInBuffer->mBuffer;

              //拷贝旧数据到新的临时缓冲

               memcpy(pInBuffer->raw, inBuffer.raw,

                        inBuffer.frameCount *channels * sizeof(int16_t));

              //保存这个临时缓冲

               mBufferQueue.add(pInBuffer);

          }

        }

}

    //如果数据全部写完

        if(pInBuffer->frameCount == 0) {

            if (mBufferQueue.size()) {

               mBufferQueue.removeAt(0);

               delete [] pInBuffer->mBuffer;

               delete pInBuffer;//释放缓冲队列对应的数据缓冲

          } else {

               break;

           }

        }

}

   ......

    return outputBufferFull;

}

说明：DT还有别的一些细节本书中没有涉及，读者可以结合自己的情况进行分析和理解。

我很羡慕iOS的应用开发者，他们面临的由于硬件变化导致的问题要少得多。

说明：这可能和我做过的应用太简单有一定关系（就是ffmpeg编解码MP3，然后播出来即可）。而libasound提供的API较多，在权衡各种情况后，我觉得它不适合快速简单应用的开发。

说明：已记不得第一次接触Desktop Check一词是什么时候了，或许当时还不叫Desktop Check，但我觉得它所蕴含的思想是正确的，是颇有价值的。

建议：无论怎么说，数据I/O毕竟是Audio系统中关键之关键，所以请读者一定要仔细阅读，体会其中精妙所在。

版权声明：本文为博主原创文章，未经博主允许不得转载。