devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深入理解Audio系统_getoutputsamplingrate getoutputframecount getoutpu

作者：从前慢现在也慢 | 2024-04-28 01:46:51

赞

踩

getoutputsamplingrate getoutputframecount getoutputlatency

原文链接：[深入理解Android卷一全文-第七章]深入理解Audio系统_Innost的专栏-CSDN博客

1 综述

Audio系统是Android平台的重要组成部分，它主要包括三方面的内容：
·  AudioRecorder和AudioTrack：这两个类属于Audio系统对外提供的API类，通过它们可以完成Android平台上音频数据的采集和输出任务。
·  AudioFlinger：它是Audio系统的工作引擎，管理着系统中的输入输出音频流，并承担音频数据的混音以及读写Audio硬件实现数据的输入输出等工作。
·  AudioPolicyService：它是Audio系统的策略控制中心，具有掌管系统中声音设备的选择和切换、音量控制等功能。
Android的Audio系统是我们分析的第一个具有相当难度的复杂系统。对于这种系统，我采取的学习方法是，以一个常见用例为核心，沿着重要函数调用的步骤逐步进行深入分析。中途若出现所需但并不熟悉的知识，则以此为契机，及时学习、思考、研究，当不熟悉的知识逐渐被自己了解掌握时，该系统的真面目也随之清晰了。

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

2 AudioTrack的破解

2.1 用例介绍

要了解AudioTrack Java API的具体信息，需要仔细阅读Android API中的相关文档。阅读API文档，是一个能快速掌握相关知识的好方法。AudioTrack API使用例子如下:

  1. //(1) 根据音频数据的特性来确定所要分配的缓冲区的最小size
  2. int bufsize = AudioTrack.getMinBufferSize(8000,    //采样率：每秒8K个点                     
  3. 　　    AudioFormat.CHANNEL_CONFIGURATION_STEREO,  //声道数：双声道           
  4.         AudioFormat.ENCODING_PCM_16BIT             //采样精度：一个采样点16比特，相当于2个字节
  5. );
  6. //(2) 创建AudioTrack
  7. AudioTrack trackplayer = new AudioTrack(
  8.                  AudioManager.STREAM_MUSIC,    //音频流类型
  9.                  8000,AudioFormat.CHANNEL_CONFIGURATION_ STEREO,
  10. 　　             AudioFormat.ENCODING_PCM_16BIT, bufsize,
  11.                  AudioTrack.MODE_STREAM);      //数据加载模式
  12. //(3) 开始播放
  13. trackplayer.play() ;
  14. ......
  15. //(4) 调用write写数据
  16. trackplayer.write(bytes_pkg, 0,bytes_pkg.length);    //往track中写数据
  17. ......
  18. //(5) 停止播放和释放资源
  19. trackplayer.stop();
  20. trackplayer.release();

上面的用例引入了两个新的概念，一个是数据加载模式，另一个是音频流类型。下面进行详细介绍。

1. AudioTrack的数据加载模式

AudioTrack有两种数据加载模式：MODE_STREAM和MODE_STATIC。

·  MODE_STREAM：在这种模式下，通过write一次次把音频数据写到AudioTrack中。这和平时通过write系统调用往文件中写数据类似，但这种工作方式每次都需要把数据从用户提供的Buffer中拷贝到AudioTrack内部的Buffer中，这在一定程度上会使引入延时。为解决这一问题，AudioTrack就引入了第二种模式。

·  MODE_STATIC：这种模式下，在play之前只需要把所有数据通过一次write调用传递到AudioTrack中的内部缓冲区，后续就不必再传递数据了。这种模式适用于像铃声这种内存占用量较小，延时要求较高的文件。但它也有一个缺点，就是一次write的数据不能太多，否则系统无法分配足够的内存来存储全部数据。

这两种模式中以MODE_STREAM模式相对常见和复杂，我们的分析将以它为主。

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

2. 音频流的类型

在AudioTrack构造函数中，会接触到AudioManager.STREAM_MUSIC这个参数。它的含义与Android系统对音频流的管理和分类有关。

Android将系统的声音分为好几种流类型，下面是几个常见的：

·  STREAM_ALARM：警告声

·  STREAM_MUSIC：音乐声，例如music等

·  STREAM_RING：铃声

·  STREAM_SYSTEM：系统声音，例如低电提示音，锁屏音等

·  STREAM_VOCIE_CALL：通话声

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

音频流类型的划分和Audio系统对音频的管理策略有关。其具体作用，在以后的分析中再做详细介绍。在目前的用例中，把它当做一个普通数值即可。

3. Buffer分配和Frame的概念

在用例中碰到的第一个重要函数就是getMinBufferSize。这个函数对于确定应用层分配多大的数据Buffer具有重要指导意义。

[-->AudioTrack.java]

  1. static public int getMinBufferSize(intsampleRateInHz, int channelConfig, intaudioFormat) {
  2.        int channelCount = 0;
  3.        switch(channelConfig) {
  4.            case AudioFormat.CHANNEL_OUT_MONO:
  5.            case AudioFormat.CHANNEL_CONFIGURATION_MONO:
  6.                channelCount = 1;
  7.                break;
  8.            case AudioFormat.CHANNEL_OUT_STEREO:
  9.            case AudioFormat.CHANNEL_CONFIGURATION_STEREO:
  10.                channelCount = 2;    //目前最多支持双声道
  11.                break;
  12.            default:
  13.                return AudioTrack.ERROR_BAD_VALUE;
  14.        }
  15.         //目前只支持PCM8和PCM16精度的音频数据   
  16.         if((audioFormat != AudioFormat.ENCODING_PCM_16BIT)
  17.            && (audioFormat != AudioFormat.ENCODING_PCM_8BIT)) {
  18.            return AudioTrack.ERROR_BAD_VALUE;
  19.         }
  20.         //对采样频率也有要求，太低或太高都不行。
  21.         if( (sampleRateInHz < 4000) || (sampleRateInHz > 48000) )
  22.             return AudioTrack.ERROR_BAD_VALUE;
  23.         /*
  24.         调用Native函数，先想想为什么，如果是简单计算，那么Java层做不到吗？
  25.         原来，还需要确认硬件是否支持这些参数，当然得进入Native层查询了
  26.         */
  27.         int size = native_get_min_buff_size(sampleRateInHz,         
  28.                  channelCount,audioFormat);                       
  29.         if((size == -1) || (size == 0)) {
  30.              return AudioTrack.ERROR;
  31.         }
  32.         else {
  33.            return size;
  34.         }
  35. }

Native的函数将查询Audio系统中音频输出硬件HAL对象的一些信息，并确认它们是否支持这些采样率和采样精度。

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

来看Native的native_get_min_buff_size函数。

[-->android_media_track.cpp]

  1. /*
  2. 注意我们传入的参数是：
  3. sampleRateInHertz = 8000，nbChannels = 2
  4. audioFormat = AudioFormat.ENCODING_PCM_16BIT
  5. */
  6. static jint android_media_AudioTrack_get_min_buff_size(                    
  7.                  JNIEnv*env,  jobject thiz,
  8.                  jintsampleRateInHertz, jint nbChannels, jint audioFormat)
  9. {
  10.     int afSamplingRate;
  11.     int afFrameCount;
  12.     uint32_t afLatency;
  13.      /*
  14.         下面这些调用涉及了AudioSystem，这个和AudioPolicy有关系。这里仅把它们看成是信息查询即可
  15.      */
  16.     //查询采样率，一般返回的是所支持的最高采样率，例如44100
  17.     if(AudioSystem::getOutputSamplingRate(&afSamplingRate) != NO_ERROR) {
  18.        return -1;
  19.     }
  20.     //1 查询硬件内部缓冲的大小，以Frame为单位。什么是Frame？
  21.     if(AudioSystem::getOutputFrameCount(&afFrameCount) != NO_ERROR) {
  22.        return -1;
  23.     }
  24.     //查询硬件的延时时间
  25.     if(AudioSystem::getOutputLatency(&afLatency) != NO_ERROR) {
  26.        return -1;
  27.     }
  28.     ......
  29.     // minBufCount表示缓冲区的最少个数，它以Frame作为单位
  30.     uint32_t minBufCount = afLatency / ((1000 *afFrameCount)/afSamplingRate);
  31.     if(minBufCount < 2) minBufCount = 2;//至少要两个缓冲
  32.     //计算最小帧个数
  33.     uint32_tminFrameCount =               
  34.          (afFrameCount*sampleRateInHertz*minBufCount)/afSamplingRate;
  35.     //下面根据最小的FrameCount计算最小的缓冲大小   
  36.     int minBuffSize = minFrameCount //计算方法完全符合我们前面关于Frame的介绍
  37.            * (audioFormat == javaAudioTrackFields.PCM16 ? 2 : 1)
  38.            * nbChannels;
  39.     return minBuffSize;
  40. }

代码中出现了音频系统中的一个重要概念：Frame（帧）。

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

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

getMinBufSize会综合考虑硬件的情况（诸如是否支持采样率，硬件本身的延迟情况等）后，得出一个最小缓冲区的大小。一般我们分配的缓冲大小会是它的整数倍。好了，介绍完一些基本概念后，开始要分析AudioTrack了。

2.2  AudioTrack（Java空间）的分析

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

1. AudioTrack的构造

回顾一下用例中调用AudioTrack构造函数的代码：

  1. AudioTrack trackplayer = new AudioTrack(
  2.                  AudioManager.STREAM_MUSIC,
  3.                  8000,AudioFormat.CHANNEL_CONFIGURATION_ STEREO,
  4. 　　             AudioFormat.ENCODING_PCM_16BIT,bufsize,
  5.                  AudioTrack.MODE_STREAM);

AudioTrack构造函数的实现在AudioTrack.java中。来看这个函数：
[-->AudioTrack.java]

  1. public AudioTrack(int streamType, intsampleRateInHz, int channelConfig,
  2.                  int audioFormat,int bufferSizeInBytes, int mode) throws IllegalArgumentException {
  3.        mState= STATE_UNINITIALIZED;
  4.        // 检查参数是否合法
  5.        audioParamCheck(streamType, sampleRateInHz, channelConfig,
  6.                          audioFormat,mode);
  7.        // bufferSizeInBytes是通过getMinBufferSize得到的，所以下面的检查肯定能通过
  8.        audioBuffSizeCheck(bufferSizeInBytes);
  9.        /*
  10.            调用native层的native_setup，构造一个WeakReference传进去。
  11.            不了解Java WeakReference读者可以上网查一下，很简单
  12.        */
  13.        int initResult = native_setup(new WeakReference<AudioTrack>(this),
  14.          mStreamType, //这个值是AudioManager.STREAM_MUSIC   
  15.          mSampleRate, //这个值是8000       
  16.          mChannels,   //这个值是2
  17.          mAudioFormat,//这个值是AudioFormat.ENCODING_PCM_16BIT      
  18.          mNativeBufferSizeInBytes,//这个值等于bufferSizeInBytes              
  19.          mDataLoadMode);//DataLoadMode是MODE_STREAM       
  20.          ....
  21. }

OK，native_setup对应的JNI层函数是android_media_AudioTrack_native_setup。一起来看：
[-->android_media_AudioTrack.cpp]

  1. static int android_media_AudioTrack_native_setup(JNIEnv* env, jobject thiz,   
  2.                          jobject weak_this,jint streamType,        
  3.                          jint sampleRateInHertz, jint channels,   
  4.                          jint audioFormat, jint buffSizeInBytes,  
  5.                          jint memoryMode)                 
  6. {
  7.     int afSampleRate;
  8.     int afFrameCount;
  9.     //进行一些信息查询
  10.     AudioSystem::getOutputFrameCount(&afFrameCount, streamType)；
  11.     AudioSystem::getOutputSamplingRate(&afSampleRate, streamType)；
  12.     AudioSystem::isOutputChannel(channels)；
  13.     //popCount用于统计一个整数中有多少位为1，有很多经典的算法
  14.     int nbChannels = AudioSystem::popCount(channels);
  15.     //Java层的值和JNI层的值转换
  16.     if(streamType == javaAudioTrackFields.STREAM_MUSIC)
  17.          atStreamType = AudioSystem::MUSIC;
  18.     int bytesPerSample = audioFormat == javaAudioTrackFields.PCM16 ? 2 : 1;
  19.     int format = audioFormat == javaAudioTrackFields.PCM16 ?
  20.                   AudioSystem::PCM_16_BIT : AudioSystem::PCM_8_BIT;
  21.     //计算以帧为单位的缓冲大小
  22.     int frameCount = buffSizeInBytes / (nbChannels * bytesPerSample);
  23.     //1 AudioTrackJniStorage对象，它保存了一些信息，后面将详细分析
  24.     AudioTrackJniStorage* lpJniStorage = new AudioTrackJniStorage();
  25.     ......
  26.     //2 创建Native层的AudioTrack对象
  27.     AudioTrack* lpTrack = new AudioTrack();
  28.     if(memoryMode == javaAudioTrackFields.MODE_STREAM) {
  29.         //3 STREAM模式
  30.         lpTrack->set(
  31.            atStreamType,//指定流类型
  32.            sampleRateInHertz,
  33.            format,// 采样点的精度，一般为PCM16或者PCM8
  34.            channels,
  35.            frameCount,
  36.            0,// flags
  37.            audioCallback, //该回调函数定义在android_media_AudioTrack.cpp中   
  38.            &(lpJniStorage->mCallbackData),
  39.            0,
  40.            0,// 共享内存,STREAM模式下为空。实际使用的共享内存由AF创建
  41.            true);//内部线程可以调用JNI函数，还记得“zygote偷梁换柱”那一节吗？
  42.     } else if (memoryMode == javaAudioTrackFields.MODE_STATIC) {
  43.           //如果是static模式，需要先创建共享内存
  44.          lpJniStorage->allocSharedMem(buffSizeInBytes);
  45.          lpTrack->set(
  46.            atStreamType,// stream type
  47.            sampleRateInHertz,
  48.            format,// word length, PCM
  49.            channels,
  50.            frameCount,
  51.            0,// flags
  52.            audioCallback,
  53.            &(lpJniStorage->mCallbackData),
  54.            0,
  55.            lpJniStorage->mMemBase, //STATIC模式下，需要传递该共享内存
  56.            true);
  57.     }
  58.     ......
  59.     /*
  60.       把JNI层中new出来的AudioTrack对象指针保存到Java对象的一个变量中，
  61.       这样就把JNI层的AudioTrack对象和Java层的AudioTrack对象关联起来了，
  62.       这是Android的常用技法。                        
  63.     */   
  64.     env->SetIntField(thiz,javaAudioTrackFields.nativeTrackInJavaObj, (int)lpTrack);
  65.     // lpJniStorage对象指针也保存到Java对象中
  66.     env->SetIntField(thiz, javaAudioTrackFields.jniData,(int)lpJniStorage);
  67. }

上边的代码列出了三个要点，这一节仅分析AudioTrackJniStorage这个类，其余的作为Native AudioTrack部分放在后面进行分析。

2. AudioTrackJniStorage分析

AudioTrackJniStorage是一个辅助类，其中有一些有关共享内存方面的较重要的知识，这里先简单介绍一下。
（1） 共享内存介绍

共享内存，作为进程间数据传递的一种手段，在AudioTrack和AudioFlinger中被大量使用。先简单了解一下有关共享内存的知识：

·  每个进程的内存空间是4GB，这个4GB是由指针长度决定的，如果指针长度为32位，那么地址的最大编号就是0xFFFFFFFF，为4GB。

·  上面说的内存空间是进程的虚拟地址空间。换言之，在应用程序中使用的指针其实是指向虚拟空间地址的。那么，如何通过这个虚地址找到存储在真实物理内存中的数据呢？

上面的问题，引出了内存映射的概念。内存映射让虚拟空间中的内存地址和真实物理内存地址之间建立了一种对应关系。也就是说，进程中操作的0x12345678这块内存的地址，在经过OS内存管理机制的转换后，它实际对应的物理地址可能会是0x87654321。当然，这一切对进程来说都是透明的，这些活都由操作系统悄悄地完成了。这和我们的共享内存会有什么关系吗？

当然有，共享内存和内存映射有着重要关系。来看图1“共享内存示意图”：

图1  共享内存示意图

图1提出了一个关键性问题，即真实内存中0x87654321标志的这块内存页（OS的内存管理机制将物理内存分成了一个个的内存页，一块内存页的大小一般是4KB）现在已经映射到了进程A中。可它能同时映射到进程B中吗？如果能，那么在进程A中，对这块内存页所写的数据在进程B中就能看见了，这岂不就做到了内存在两个进程间共享吗？事实确实如此。这个机制是由操作系统提供和实现的，原理很简单，实现起来却很复杂，这里就不深究了。
如何创建和共享内存呢？
不同系统会有不同的方法。Linux平台的一般做法是：
·  进程A创建并打开一个文件，得到一个文件描述符fd。
·  通过mmap调用将fd映射成内存映射文件。在mmap调用中指定特定参数表示要创建进程间共享内存。
·  进程B打开同一个文件，也得到一个文件描述符，这样A和B就打开了同一个文件。
·  进程B也要用mmap调用指定参数表示想使用共享内存，并传递打开的fd。这样A和B就通过打开同一个文件并构造内存映射，实现了进程间内存共享。
注意，这个文件也可以是设备文件。

参考：

linux 中mmap的用法 - jeremyatchina - 博客园

认真分析mmap：是什么 为什么 怎么用 - 胡潇 - 博客园
总之，AT和AF之间的数据传递，就是通过共享内存方式来完成的。这种方式对于跨进程的大数据量传输来说，是非常高效的。

（2） MemoryHeapBase和MemoryBase类介绍

AudioTrackJniStorage用到了Android对共享内存机制的封装类。所以我们有必要先看看AudioTrackJniStorage的内容。

[-->android_media_AudioTrack.cpp::AudioTrackJniStorage相关]

  1. //下面这个结构就是保存一些变量，没有什么特别的作用
  2. struct audiotrack_callback_cookie {
  3.    jclass      audioTrack_class;
  4.    jobject     audioTrack_ref;
  5. };
  6.  
  7. class AudioTrackJniStorage {
  8.    public:
  9.       sp<MemoryHeapBase>    mMemHeap;//这两个Memory很重要
  10.       sp<MemoryBase>         mMemBase;
  11.       audiotrack_callback_cookie mCallbackData;
  12.       int                       mStreamType;
  13.       boolallocSharedMem(int sizeInBytes) {
  14.       /*
  15.       注意关于MemoryHeapBase和MemoryBase的用法。   
  16.       先new一个MemoryHeapBase，再以它为参数new一个MemoryBase        
  17.       */  
  18.       //1 MemoryHeapBase
  19.       mMemHeap = new MemoryHeapBase(sizeInBytes, 0,"AudioTrack Heap Base");
  20.       //2 MemoryBase
  21.       mMemBase= new MemoryBase(mMemHeap, 0, sizeInBytes);
  22.       return true;
  23.    }
  24. };

注意代码中所标识的地方，它们很好地展示了这两个Memory类的用法。在介绍它们之前，先来看图2中与这两个Memory有关的家谱。
MemoryBase----->MemoryHeapBase（关联关系）

图2  MemoryHeapBase和MemoryBase的家谱

MemoryHeapBase是一个基于Binder通信的类，根据前面的Binder知识，BpMemoryHeapBase由客户端使用，而MemoryHeapBase完成BnMemoryHeapBase的业务工作。从MemoryHeapBase开始分析。它的使用方法是：

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

它的代码在MemoryHeapBase.cpp中。
[-->MemoryHeapBase.cpp]

  1. /*
  2.    MemoryHeapBase有两个构造函数，我们用的是第一个。
  3.    size表示共享内存大小，flags为0，name为"AudioTrackHeap Base"
  4. */
  5. MemoryHeapBase::MemoryHeapBase(size_t size,uint32_t flags,char const * name)
  6.     :mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),
  7.      mDevice(0), mNeedUnmap(false)
  8. {
  9.     const size_t pagesize = getpagesize();//获取系统中的内存页大小，一般为4KB
  10.     size =((size + pagesize-1) & ~(pagesize-1));
  11.    /*   
  12.      创建共享内存，ashmem_create_region函数由libcutils提供。
  13.      在真实设备上将打开/dev/ashmem设备得到一个文件描述符,在模拟器上则创建一个tmp文件    
  14.    */
  15.    int fd= ashmem_create_region(name == NULL ? "MemoryHeapBase" : name, size);
  16.    //下面这个函数将通过mmap方式得到内存地址，这是Linux的标准做法，有兴趣的读者可以看看
  17.    mapfd(fd,size);
  18. }

MemoryHeapBase构造完后，得到了以下结果：
·  mBase变量指向共享内存的起始位置。
·  mSize是所要求分配的内存大小。
·  mFd是ashmem_create_region返回的文件描述符。
另外，MemoryHeapBase提供了以下几个函数，可以获取共享内存的大小和位置。由于这些函数都很简单，仅把它们的作用描述一下即可。

  1. MemoryHeapBase::getBaseID() //返回mFd，如果为负数，表明刚才创建共享内存失败了
  2. MemoryHeapBase::getBase()  //共享内存起始地址
  3. MemoryHeapBase::getSize() //返回mSize，表示内存大小

MemoryHeapBase确实比较简单，它通过ashmem_create_region得到一个文件描述符。
说明：Android系统通过ashmem创建共享内存的原理，和Linux系统中通过打开文件创建共享内存的原理类似，但ashmem设备驱动在这方面做了较大的改进，例如增加了引用计数、延时分配物理内存的机制（即真正使用的时候才去分配内存）等。这些内容，感兴趣的读者还可以自行对其研究。
那么，MemoryBase是何物？它又有什么作用？
MemoryBase也是一个基于Binder通信的类，它比起MemoryHeapBase就更显简单了，看起来更像是一个辅助类。它的声明在MemoryBase.h中。一起来看：
[-->MemoryBase.h::MemoryBase声明]

  1. class MemoryBase : public BnMemory
  2. {
  3. public:
  4.    MemoryBase(const sp<IMemoryHeap>& heap, ssize_t offset, size_tsize);
  5.    virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size)const;
  6. protected:
  7.    size_t getSize() const { return mSize; }//返回大小
  8.    ssize_t getOffset() const { return mOffset;}//返回偏移量
  9.    //返回MemoryHeapBase对象     
  10.    const sp<IMemoryHeap>& getHeap() const { return mHeap;}
  11. };
  12. //MemoryBase的构造函数
  13. MemoryBase::MemoryBase(constsp<IMemoryHeap>& heap, ssize_t offset, size_t size)
  14.     :mSize(size), mOffset(offset), mHeap(heap)
  15. {
  16. }

MemoryHeapBase和MemoryBase都够简单吧？总结起来不过是：
·  分配了一块共享内存，这样两个进程可以共享这块内存。
·  基于Binder通信，这样使用这两个类的进程就可以交互了。
这两个类在后续的讲解中会频繁碰到，但不必对它们做深入分析，只需把它当成普通的共享内存看待即可。
提醒：这两个类没有提供同步对象来保护这块共享内存，所以后续在使用这块内存时，必然需要一个跨进程的同步对象来保护它。这一点，是我在AT中第一次见到它们时想到的，不知道你是否注意过这个问题。

3. play和write的分析

还记得用例中的(3)和(4)关键代码行吗？

  1. //(3) 开始播放
  2. trackplayer.play() ;
  3. //(4) 调用write写数据
  4. trackplayer.write(bytes_pkg, 0,bytes_pkg.length) ;//往track中写数据

现在就来分析它们。我们要直接转向JNI层来进行分析。
（1） play的分析
先看看play函数对应的JNI层函数，它是android_media_AudioTrack_start。
[-->android_media_AudioTrack.cpp]

  1. static void android_media_AudioTrack_start(JNIEnv *env,jobject thiz)
  2. {
  3.   /*
  4.    从Java的AudioTrack对象中获取对应Native层的AudioTrack对象指针。
  5.    从int类型直接转换成指针，不过要是以后ARM平台支持64位指针了，代码就得大修改了。
  6.   */
  7.    AudioTrack *lpTrack = (AudioTrack *)env->GetIntField(
  8.         thiz,javaAudioTrackFields.nativeTrackInJavaObj);
  9.    lpTrack->start(); //很简单的调用
  10. }

play函数太简单了，至于它调用的start，等到Native层进行AudioTrack分析时，我们再去观察。
（2） write的分析
Java层的write函数有两个：
·  一个是用来写PCM16数据的，它对应的一个采样点的数据量是两个字节。
·  另外一个用来写PCM8数据的，它对应的一个采样点的数据量是一个字节。
我们的用例中采用的是PCM16数据。它对应的JNI层函数是android_media_AudioTrack_native_write_short，一起来看：
[-->android_media_AudioTrack.cpp]

  1. static jint android_media_AudioTrack_native_write_short(
  2.                  JNIEnv*env,  jobject thiz,
  3.                  jshortArrayjavaAudioData,jint offsetInShorts,
  4.                  jintsizeInShorts,jint javaAudioFormat) {
  5.         return(android_media_AudioTrack_native_write(
  6.                  env,thiz,(jbyteArray)javaAudioData,offsetInShorts*2,
  7.                  sizeInShorts*2,javaAudioFormat)/ 2);
  8. }

无论PCM16还是PCM8数据，最终都会调用writeToTrack函数。
[-->android_media_AudioTrack.cpp]

  1. jint writeToTrack(AudioTrack* pTrack, jintaudioFormat,
  2.                  jbyte*data,jint offsetInBytes, jint sizeInBytes) {
  3.    ssize_t written = 0;
  4.   /*
  5.      如果是STATIC模式，sharedBuffer()返回不为空
  6.      如果是STREAM模式，sharedBuffer()返回空
  7.   */
  8.    if (pTrack->sharedBuffer() == 0) {
  9.         //我们的用例是STREAM模式，调用write函数写数据
  10.         written = pTrack->write(data + offsetInBytes, sizeInBytes);
  11.    } else{
  12.         if (audioFormat == javaAudioTrackFields.PCM16){
  13.            if ((size_t)sizeInBytes > pTrack->sharedBuffer()->size()) {
  14.                sizeInBytes = pTrack->sharedBuffer()->size();
  15.            }
  16.           //在STATIC模式下，直接把数据memcpy到共享内存，记住在这种模式下要先调用write
  17.           //后调用play
  18.           memcpy(pTrack->sharedBuffer()->pointer(),
  19.                          data+ offsetInBytes, sizeInBytes);
  20.           written = sizeInBytes;
  21.         }else if (audioFormat == javaAudioTrackFields.PCM8) {
  22.           //如果是PCM8数据，则先转换成PCM16数据再拷贝
  23.           ......
  24.     }
  25.     return written;
  26. }

play和write这两个函数还真是比较简单，须知，大部分工作还都是由Native的AudioTrack来完成的。继续Java层的分析。

4. release的分析

当数据都write完后，需要调用stop停止播放，或者直接调用release来释放相关资源。由于release和stop有一定的相关性，这里只分析release调用。
[-->android_media_AudioTrack.cpp] 

  1. static void android_media_AudioTrack_native_release(JNIEnv *env,  jobject thiz) {
  2.     //调用android_media_AudioTrack_native_finalize真正释放资源
  3.     android_media_AudioTrack_native_finalize(env, thiz);
  4.     //之前保存在Java对象中的指针变量此时都要设置为零
  5.     env->SetIntField(thiz, javaAudioTrackFields.nativeTrackInJavaObj, 0);
  6.     env->SetIntField(thiz, javaAudioTrackFields.jniData, 0);
  7. }
  8.  
  9. static voidandroid_media_AudioTrack_native_finalize(JNIEnv *env, jobject thiz) {
  10.    AudioTrack *lpTrack = (AudioTrack *)env->GetIntField(
  11.                            thiz, javaAudioTrackFields.nativeTrackInJavaObj);
  12.     if(lpTrack) {
  13.        lpTrack->stop();//调用stop
  14.        delete lpTrack; //调用AudioTrack的析构函数
  15. }
  16. ......
  17. }

至此，在Java空间的分析工作就完成了。但在进入Native空间的分析之前，要总结一下Java空间使用Native的AudioTrack的流程，只有这样，在进行Native空间分析时才能有章可循。

5. AudioTrack（Java空间）的分析总结

AudioTrack在JNI层使用了Native的AudioTrack对象，总结一下调用Native对象的流程：

·  new一个AudioTrack，使用无参的构造函数。

·  调用set函数，把Java层的参数传进去，另外还设置了一个audiocallback回调函数。

·  调用了AudioTrack的start函数。

·  调用AudioTrack的write函数。

·  工作完毕后，调用stop。

·  最后就是Native对象的delete。

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

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

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

2.3  AudioTrack（Native空间）的分析

1. new AudioTrack和set分析

Native的AudioTrack代码在AudioTrack.cpp中。这一节，分析它的构造函数和set调用。

[-->AudioTrack.cpp]

  1. AudioTrack::AudioTrack()//我们使用无参构造函数
  2.     :mStatus(NO_INIT) //把状态初始化成NO_INIT。Android的很多类都采用了这种状态控制
  3. {
  4. }

再看看set调用，这个函数有很多内容。
[-->AudioTrack.cpp]

  1. /*
  2.    还记得我们传入的参数吗？
  3.    streamType=STREAM_MUSIC,sampleRate=8000,format=PCM_16
  4.    channels=2，frameCount由计算得来，可以假设一个值，例如1024，不影响分析。
  5.    flags=0,cbf=audiocallback, user为cbf的参数，notificationFrames=0
  6.    因为是流模式，所以sharedBuffer=0。threadCanCallJava 为true
  7. */
  8. status_t AudioTrack::set(int streamType,uint32_t sampleRate,int format,
  9.        int channels,int frameCount,uint32_t flags,callback_t cbf,void* user,
  10.        int notificationFrames,const sp<IMemory>& sharedBuffer,
  11.        bool threadCanCallJava)
  12. {
  13.    //前面有一些判断，都是和AudioSystem有关的，以后再分析
  14.    ......
  15.    /*
  16.     audio_io_handle_t是一个int类型，通过typedef定义，这个值的来历非常复杂，
  17.     涉及AudioFlinger和AudioPolicyService， 后边的分析试将其解释清楚。
  18.     这个值主要被AudioFlinger使用，用来表示内部的工作线程索引号。AudioFlinger会根据
  19.     情况创建几个工作线程，下面的AudioSystem::getOutput会根据流类型等其他参数最终选
  20.     取一个合适的工作线程，并返回它在AF中的索引号。而AudioTrack一般使用混音线程（Mixer Thread）
  21.    */
  22.    audio_io_handle_t output = AudioSystem::getOutput(
  23.                          (AudioSystem::stream_type)streamType,
  24.                           sampleRate,format, channels,
  25.                          (AudioSystem::output_flags)flags);
  26.    //调用creatTrack
  27.    status_t status = createTrack(streamType, sampleRate, format,channelCount,
  28.                                  frameCount,flags, sharedBuffer, output);
  29.    //cbf是JNI层传入的回调函数audioCallback，如果用户设置了回调函数，则启动一个线程
  30.    if (cbf!= 0) {
  31.        mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
  32.    }
  33.    return NO_ERROR;
  34. }

再看createTrack函数：
[-->AudioTrack.cpp]

  1. status_t AudioTrack::createTrack(int streamType,uint32_t sampleRate,
  2.        int format,int channelCount,int frameCount, uint32_t flags,
  3.        const sp<IMemory>& sharedBuffer, audio_io_handle_t output)
  4. {
  5.    status_t status;
  6.    /*
  7.     得到AudioFlinger的Binder代理端BpAudioFlinger。
  8.     关于这部分内容，我们已经很熟悉了，以后的讲解会跨过Binder，直接分析Bn端的实现
  9.    */
  10.    const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
  11.    /*
  12.     向AudioFinger发送createTrack请求。注意其中的几个参数，
  13.     在STREAM模式下sharedBuffer为空
  14.     output为AudioSystem::getOutput得到一个值，代表AF中的线程索引号
  15.     该函数返回IAudioTrack（实际类型是BpAudioTrack）对象，后续AF和AT的交互就是围绕IAudioTrack进行的
  16.    */
  17.    sp<IAudioTrack> track = audioFlinger->createTrack(getpid(),
  18.         streamType,sampleRate,format,channelCount,frameCount,
  19.         ((uint16_t)flags) << 16,sharedBuffer,output,&status);
  20.    /*
  21.     在STREAM模式下，没有在AT端创建共享内存，但前面提到了AT和AF的数据交互是
  22.     通过共享内存完成的，这块共享内存最终由AF的createTrack创建。我们以后分析AF时
  23.     再做介绍。下面这个调用会取出AF创建的共享内存
  24.    */
  25.    sp<IMemory> cblk = track->getCblk();
  26.    mAudioTrack.clear();//sp的clear
  27.    mAudioTrack= track;
  28.    mCblkMemory.clear();
  29.    mCblkMemory= cblk;  //cblk是control block的简写
  30.    /*
  31.     IMemory的pointer在此处将返回共享内存的首地址，类型为void*，
  32.     static_cast直接把这个void*类型转成audio_track_cblk_t，表明这块内存的首部中存在
  33.     audio_track_cblk_t这个对象
  34.    */
  35.    mCblk= static_cast<audio_track_cblk_t*>(cblk->pointer());
  36.    mCblk->out = 1;//out为1表示输出，out为0表示输入
  37.    mFrameCount = mCblk->frameCount;
  38.    if(sharedBuffer == 0) {
  39.        //buffers指向数据空间，它的起始位置是共享内存的首部加上audio_track_cblk_t的大小
  40.        mCblk->buffers= (char*)mCblk + sizeof(audio_track_cblk_t);
  41.    } else {
  42.        //STATIC模式下的处理
  43.         mCblk->buffers =sharedBuffer->pointer();
  44.         mCblk->stepUser(mFrameCount);//更新数据位置，后面要分析stepUser的作用
  45.    }
  46.    return NO_ERROR;
  47. }

（1）IAudioTrack和AT、AF的关系
上面的createTrack函数中突然冒出来一个新面孔，叫IAudioTrack。关于它和AT及AF的关系，我们用图3来表示：

图3  IAudioTrack和AT、AF的关系
至于IAudioTrack在AF端到底是什么，在分析AF时会有详细解释。

（2）共享内存及其Control Block
通过前面的代码分析，我们发现IAudioTrack中有一块共享内存，其头部是一个audio_track_cblk_t（简称CB）对象，在该对象之后才是数据缓冲。这个CB对象有什么作用呢？
还记得前面提到的那个深层次思考的问题吗？即MemoryHeapBase和MemoryBase都没有提供同步对象，那么，AT和AF作为典型的数据生产者和消费者，如何正确协调二者生产和消费的步调呢？
Android为顺应民意，便创造出了这个CB对象，其主要目的就是协调和管理AT和AF二者数据生产和消费的步伐。先来看CB都管理些什么内容。它的声明在AudioTrackShared.h中，而定义却在AudioTrack.cpp中。
[-->AudioTrackShared.h::audio_track_cblk_t声明]

  1. struct audio_track_cblk_t
  2. {
  3.        Mutex       lock;
  4.        Condition   cv;//这是两个同步变量，初始化的时候会设置为支持跨进程共享
  5.       /*
  6.        一块数据缓冲同时被生产者和消费者使用，最重要的就是维护它的读写位置了。
  7.        下面定义的这些变量就和读写的位置有关，虽然它们的名字并不是那么直观。
  8.        另外，这里提一个扩展问题，读者可以思考一下：volatile支持跨进程吗？要回答这个问题需要理解volatile、CPU Cache机制和共享内存的本质
  9.       */
  10.        volatile    uint32_t    user;   //当前写位置（即生产者已经写到什么位置了）
  11.        volatile    uint32_t   server;  //当前读位置
  12.       /*
  13.        userBase和serverBase要和user及server结合起来用。
  14.        CB巧妙地通过上面几个变量把一块线性缓冲当做环形缓冲来使用，以后将单独分析这个问题
  15.       */
  16.        uint32_t    userBase;  
  17.        uint32_t    serverBase;
  18.        void*       buffers; //指向数据缓冲的首地址
  19.        uint32_t    frameCount;//数据缓冲的总大小，以Frame为单位
  20.        uint32_t    loopStart; //设置打点播放（即设置播放的起点和终点）
  21.        uint32_t    loopEnd;
  22.        int         loopCount;//循环播放的次数
  23.        volatile    union {
  24.            uint16_t    volume[2];
  25.            uint32_t    volumeLR;
  26.        }; //和音量有关系，可以不管它
  27.        uint32_t    sampleRate;//采样率
  28.        uint32_t    frameSize;//一单位Frame的数据大小
  29.        uint8_t     channels;//声道数
  30.        uint8_t     flowControlFlag;//控制标志，见下文分析
  31.        uint8_t     out; // AudioTrack为1，AudioRecord为0
  32.        uint8_t     forceReady;
  33.        uint16_t    bufferTimeoutMs;
  34.        uint16_t    waitTimeMs;
  35.        //下面这几个函数很重要，后续会详细介绍它们
  36.        uint32_t    stepUser(uint32_tframeCount);//更新写位置
  37.        bool        stepServer(uint32_tframeCount);//更新读位置
  38.        void*       buffer(uint32_toffset) const;//返回可写空间起始位置
  39.        uint32_t    framesAvailable();//还剩多少空间可写
  40.        uint32_t    framesAvailable_l();
  41.        uint32_t    framesReady();//是否有可读数据
  42. }

关于CB对象，这里要专门讲解一下其中flowControlFlag的意思：
·  对于音频输出来说，flowControlFlag对应着underrun状态，underrun状态是指生产者提供数据的速度跟不上消费者使用数据的速度。这里的消费者指的是音频输出设备。由于音频输出设备采用环形缓冲方式管理，当生产者没有及时提供新数据时，输出设备就会循环使用缓冲中的数据，这样就会听到一段重复的声音。这种现象一般被称作“machinegun”。对于这种情况，一般的处理方法是暂停输出，等数据准备好后再恢复输出。
·  对于音频输入来说，flowControlFlag对于着overrun状态，它的意思和underrun一样，只是这里的消费者变成了音频输入设备，而生产者变成了Audio系统的AudioRecord。
说明：目前这个参数并不直接和音频输入输出设备的状态有关系。它在AT和AF中的作用必须结合具体情况，才能分析。
图4表示CB对象和它所驻留的共享内存间的关系：

图4  共享内存和CB的关系
注意：CB实际是按照环形缓冲来处理数据读写的，所以user和server的真实作用还需要结合userBase和serverBase。图4只是一个示意图。
另外，关于CB，还有一个神秘的问题。先看下面这行代码：
mCblk =static_cast<audio_track_cblk_t*>(cblk->pointer());
这看起来很简单，但仔细琢磨会发现其中有一个很难解释的问题：
cblk->pointer返回的是共享内存的首地址，怎么把audio_track_cblk_t对象塞到这块内存中呢？这个问题将通过对AudioFlinger的分析，得到答案。
说明：关于audio_track_cblk_t的使用方式，后文会有详细分析。

2. write输入数据

write函数涉及Audio系统中最重要的关于数据如何传输的问题。回顾一下我们已了解的信息：
·  有一块共享内存。
·  有一个控制结构，里边有一些支持跨进程的同步变量。
有了这些东西，write的工作方式就非常简单了：
·  通过共享内存传递数据。
·  通过控制结构协调生产者和消费者的步调。
重点强调：带着问题和思考来分析代码相当于“智取”，它比一上来就直接扎入源码的“强攻”要高明得多。希望我们能掌握这种思路和方法。
好了，现在开始分析write，看看它的实现是不是如所想的那样。
[-->AudioTrack.cpp]

  1. ssize_t AudioTrack::write(const void* buffer,size_t userSize)
  2. {
  3.     if(mSharedBuffer != 0) return INVALID_OPERATION;
  4.     if(ssize_t(userSize) < 0) {
  5.        return BAD_VALUE;
  6.     }
  7.     ssize_t written = 0;
  8.     const int8_t *src = (const int8_t *)buffer;
  9.     Buffer audioBuffer; // Buffer是一个辅助性的结构
  10.     do {
  11.        //以帧为单位
  12.        audioBuffer.frameCount = userSize/frameSize();
  13.        //obtainBuffer从共享内存中得到一块空闲的数据块
  14.        status_terr = obtainBuffer(&audioBuffer, -1);
  15.        ......
  16.        size_t toWrite;
  17.        if(mFormat == AudioSystem::PCM_8_BIT && !(mFlags &AudioSystem::OUTPUT_FLAG_DIRECT)) {
  18.           //PCM8数据转PCM16
  19.        }else {
  20.           //空闲数据缓冲的大小是audioBuffer.size。
  21.           //地址在audioBuffer.i8中，数据传递通过memcpy完成
  22.           toWrite = audioBuffer.size;
  23.           memcpy(audioBuffer.i8, src, toWrite);
  24.           src += toWrite;
  25.        }
  26.        userSize -= toWrite;
  27.        written += toWrite;
  28.        //releaseBuffer更新写位置，同时会触发消费者
  29.        releaseBuffer(&audioBuffer);
  30.     }while (userSize);
  31.     return written;
  32. }

通过write函数，会发现数据的传递其实是很简单的memcpy，但消费者和生产者的协调，则是通过obtainBuffer与releaseBuffer来完成的。现在来看这两个函数。

3. obtainBuffer和releaseBuffer

这两个函数展示了做为生产者的AT和CB对象的交互方法。先简单看看，然后把它们之间交互的流程记录下来，以后在CB对象的单独分析部分，我们再来做详细介绍。
[-->AudioTrack.cpp]

  1. status_t AudioTrack::obtainBuffer(Buffer*audioBuffer, int32_t waitCount)
  2. {
  3.     int active;
  4.     status_t result;
  5.     audio_track_cblk_t* cblk = mCblk;
  6.     ......
  7.     //1 调用framesAvailable，得到当前可写的空间大小
  8.     uint32_t framesAvail = cblk->framesAvailable();
  9.     if(framesAvail == 0) {
  10.         ......
  11.         //如果没有可写空间，则要等待一段时间
  12.         result= cblk->cv.waitRelative(cblk->lock,milliseconds(waitTimeMs));
  13.         ......
  14.     }
  15.     cblk->waitTimeMs = 0;
  16.     if(framesReq > framesAvail) {
  17.        framesReq = framesAvail;
  18.     }
  19.     //user为可写空间起始地址
  20.     uint32_t u = cblk->user;
  21.     uint32_tbufferEnd = cblk->userBase + cblk->frameCount;
  22.     if (u+ framesReq > bufferEnd) {
  23.        framesReq = bufferEnd - u;
  24.     }
  25.      ......
  26.     //2 调用buffer，得到可写空间的首地址
  27.     audioBuffer->raw = (int8_t *)cblk->buffer(u);
  28.     active = mActive;
  29.     return active ? status_t(NO_ERROR) : status_t(STOPPED);
  30. }

obtainBuffer的功能，就是从CB管理的数据缓冲中得到一块可写空间，而releaseBuffer，则是在使用完这块空间后更新写指针的位置。
[-->AudioTrack.cpp]

  1. void AudioTrack::releaseBuffer(Buffer*audioBuffer)
  2. {
  3.    audio_track_cblk_t* cblk = mCblk;
  4.    cblk->stepUser(audioBuffer->frameCount);//3 调用stepUser更新写位置
  5. }

obtainBuffer和releaseBuffer与CB交互，一共会有三个函数调用，如下所示：
·  framesAvailable判断是否有可写空间。
·  buffer得到写空间起始地址。
·  stepUser更新写位置。
请记住这些流程，以后在分析CB时会发现它们有重要作用。

4. delete AudioTrack

到这里，AudioTrack的使命就进入倒计时阶段了。来看在它生命的最后还会做一些什么工作。
[-->AudioTrack.cpp]

  1. AudioTrack::~AudioTrack()
  2. {
  3.     if(mStatus == NO_ERROR) {
  4.         stop();//调用stop
  5.         if(mAudioTrackThread != 0) {
  6.            //通知AudioTrackThread退出
  7.            mAudioTrackThread->requestExitAndWait();
  8.            mAudioTrackThread.clear();
  9.         }
  10.        mAudioTrack.clear();
  11.        //将残留在IPCThreadState 发送缓冲区的信息发送出去
  12.        IPCThreadState::self()->flushCommands();
  13.     }
  14. }

如果不调用stop，析构函数也会先调用stop，这个做法很周到。
[-->AudioTrack.cpp]

  1. void AudioTrack::stop()
  2. {
  3.     sp<AudioTrackThread> t = mAudioTrackThread;
  4.     if (t!= 0) {
  5.        t->mLock.lock();
  6.     }
  7.     if(android_atomic_and(~1, &mActive) == 1) {
  8.        mCblk->cv.signal();
  9.        /*
  10.         mAudioTrack是IAudioTrack类型，其stop的最终处理在AudioFlinger端
  11.        */
  12.        mAudioTrack->stop();
  13.        //清空循环播放设置
  14.        setLoop(0, 0, 0);
  15.        mMarkerReached = false;
  16.        if (mSharedBuffer != 0) {
  17.            flush();
  18.        }
  19.        if(t != 0) {
  20.            t->requestExit();//请求退出AudioTrackThread
  21.        }else {
  22.            setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_NORMAL);
  23.        }
  24.     }
  25.     if (t!= 0) {
  26.       t->mLock.unlock();
  27.     }
  28. }

stop的工作比较简单，就是调用IAudioTrack的stop，并且还要求退出回调线程。要重点关注IAudioTrack的stop函数，这个将做为AT和AF交互流程中的一个步骤来分析。

2.4  AudioTrack的总结

AudioTrack就这样完了吗？它似乎也不是很复杂。其实，在进行AT分析时，对于一些难度比较大的地方暂时没做介绍。

OK，在完成对AudioTrack的分析之前，应把它和AudioFlinger交互的流程总结下，如图5所示。这些流程是以后攻克AudioFlinger的重要武器。

图5  AT和AF的交互流程图

3  AudioFlinger的破解

AudioFlinger是Audio系统的核心，来自AudioTrack的数据，最终在这里得到处理并被写入Audio HAL层。

3.1  AudioFlinger的诞生

AudioFlinger驻留于MediaServer进程中。回顾一下它的代码，如下所示：
[-->Main_MediaServer.cpp]

  1. int main(int argc, char** argv)
  2. {
  3.    sp<ProcessState> proc(ProcessState::self());
  4.    sp<IServiceManager>sm = defaultServiceManager();
  5.    ....
  6.    //很好，AF和APS都驻留在这个进程
  7.    AudioFlinger::instantiate();
  8.    AudioPolicyService::instantiate();
  9.    ....
  10.    ProcessState::self()->startThreadPool();
  11.    IPCThreadState::self()->joinThreadPool();
  12. }

1. AudioFlinger的构造

[-->AudioFlinger.cpp]

  1. void AudioFlinger::instantiate() {
  2.    defaultServiceManager()->addService( //把AF添加到ServiceManager中
  3.            String16("media.audio_flinger"), new AudioFlinger());
  4. }

再来看它的构造函数：
[-->AudioFlinger.cpp]

  1. AudioFlinger::AudioFlinger(): BnAudioFlinger(),
  2.        mAudioHardware(0), //代表Audio硬件的HAL对象
  3.        mMasterVolume(1.0f),mMasterMute(false), mNextThreadId(0)
  4. {
  5.     mHardwareStatus= AUDIO_HW_IDLE;
  6.     //创建代表Audio硬件的HAL对象
  7.     mAudioHardware = AudioHardwareInterface::create();
  8.     mHardwareStatus = AUDIO_HW_INIT;
  9.     if(mAudioHardware->initCheck() == NO_ERROR) {
  10.        //设置系统初始化的一些值，有一部分通过Audio HAL设置到硬件中
  11.        setMode(AudioSystem::MODE_NORMAL);
  12.        setMasterVolume(1.0f);
  13.        setMasterMute(false);
  14.     }
  15. }

AudioHardwareInterface是Android对代表Audio硬件的封装，属于HAL层。HAL层的具体功能，由各个硬件厂商根据所选硬件的情况来实现，多以动态库的形式提供。这里，简单分析一下Audio HAL的接口，至于其具体实现就不做过多的探讨了。

2. AudioHardwareInterface介绍

AudioHardwareInterface接口的定义在AudioHardwareInterface.h中。先看看它。
[-->AudioHardwareInterface.h::AudioHardwareInterface声明]

  1. class AudioHardwareInterface
  2. {
  3. public:
  4.     virtual ~AudioHardwareInterface() {}
  5.     //用于检查硬件是否初始化成功，返回的错误码定义在include/utils/Errors.h
  6.     virtual status_t    initCheck() =0;
  7.     //设置通话音量，范围从0到1.0
  8.     virtual status_t   setVoiceVolume(float volume) = 0;
  9.     /*
  10.        设置除通话音量外的其他所有音频流类型的音量，范围从0到1.0，如果硬件不支持的话，
  11.        这个功能会由软件层的混音器完成
  12.     */
  13.     virtual status_t   setMasterVolume(float volume) = 0;
  14.     /*
  15.        设置模式，NORMAL的状态为普通模式，RINGTONE表示来电模式（这时听到的声音是来电铃声）
  16.        IN_CALL表示通话模式（这时听到的声音是手机通话过程中的语音）
  17.     */
  18.     virtual status_t    setMode(intmode) = 0;
  19.     // 和麦克相关
  20.     virtual status_t   setMicMute(bool state) = 0;
  21.     virtual status_t   getMicMute(bool* state) = 0;
  22.     // 设置/获取配置参数，采用key/value的组织方式
  23.     virtual status_t   setParameters(const String8& keyValuePairs) = 0;
  24.     virtual String8    getParameters(const String8& keys) = 0;
  25.     // 根据传入的参数得到输入缓冲的大小，返回0表示其中某个参数的值Audio HAL不支持
  26.     virtual size_t    getInputBufferSize(uint32_tsampleRate, int format,
  27.                                                 int channelCount) = 0;
  28.     /*下面这几个函数非常重要 */
  29.     /*
  30.          openOutputStream：创建音频输出流对象（相当于打开音频输出设备）
  31.          AF可以往其中write数据，指针型参数将返回该音频输出流支持的类型、声道数、采样率等
  32.     */
  33.     virtual AudioStreamOut* openOutputStream(
  34.                                 uint32_tdevices,
  35.                                 int *format=0,
  36.                                 uint32_t*channels=0,
  37.                                 uint32_t*sampleRate=0,
  38.                                 status_t*status=0) = 0;
  39.     //关闭音频输出流
  40.     virtual    void       closeOutputStream(AudioStreamOut* out) = 0;
  41.     /* 创建音频输入流对象（相当于打开音频输入设备），AF可以read数据*/
  42.     virtual AudioStreamIn* openInputStream(
  43.                                 uint32_tdevices,
  44.                                 int *format,
  45.                                 uint32_t*channels,
  46.                                 uint32_t *sampleRate,
  47.                                 status_t*status,
  48.                                AudioSystem::audio_in_acoustics acoustics) = 0;
  49.     virtual    void        closeInputStream(AudioStreamIn* in) =0;
  50.     //关闭音频输入流
  51.     virtual status_t dumpState(int fd, const Vector<String16>&args) = 0;
  52.     //静态create函数，使用设计模式中的工厂模式，具体返回的对象由厂商根据硬件的情况决定
  53.     staticAudioHardwareInterface* create();
  54.     ......
  55. };

根据上面的代码，可以得出以下结论：
·  AudioHardwareInterface管理音频输出设备对象（AudioStreamOut）和音频输入设备对象（AudioStreamIn）的创建。
·  通过AudioHardwareInterface可设置音频系统的一些参数。
图6表示AudioHardwareInterface和音频输入输出对象之间的关系以及它们的派生关系：

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

3.2 通过流程分析AudioFlinger

图5中说明的AT和AF交互的流程，对于分析AF来说非常重要。先来回顾一下图5的流程：

·  AT调用createTrack，得到一个IAudioTrack对象。

·  AT调用IAudioTrack对象的start，表示准备写数据了。

·  AT通过write写数据，这个过程和audio_track_cblk_t有着密切关系。

·  最后AT调用IAudioTrack的stop或delete IAudioTrack结束工作。

至此，上面的每一步都很清楚了。根据Binder知识，AT调用的这些函数最终都会在AF端得到实现，所以可直接从AF端开始。

1. createTrack的分析

按照前面的流程步骤，第一个被调用的函数会是createTrack，请注意在用例中传的参数。

[-->AudioFlinger.cpp]

  1. sp<IAudioTrack> AudioFlinger::createTrack(
  2.        pid_t pid,//AT的pid号
  3.        int streamType,//流类型，用例中是MUSIC类型
  4.        uint32_t sampleRate,//8000 采样率
  5.        int format,//PCM_16类型
  6.        int channelCount,//2，双声道
  7.        int frameCount,//需要创建缓冲的大小，以帧为单位
  8.        uint32_t flags,
  9.        const sp<IMemory>& sharedBuffer,//AT传入的共享buffer，这里为空
  10.        int output,//这个值前面提到过，是AF中的工作线程索引号
  11.        status_t *status)
  12. {
  13.    sp<PlaybackThread::Track> track;
  14.    sp<TrackHandle> trackHandle;
  15.    sp<Client> client;
  16.    wp<Client> wclient;
  17.    status_t lStatus;
  18.    {
  19.        Mutex::Autolock _l(mLock);
  20.        //output代表索引号，这里根据索引号找到一个工作线程，它是一个PlaybackThread
  21.        PlaybackThread *thread = checkPlaybackThread_l(output);
  22.        //看看这个进程是否已经是AF的Client,AF根据进程pid来标识不同的Client
  23.        wclient = mClients.valueFor(pid);
  24.        if(wclient != NULL) {
  25.        }else {
  26.            //如果还没有这个Client信息，则创建一个，并加入到mClients中去
  27.            client = new Client(this, pid);
  28.            mClients.add(pid, client);
  29.         }
  30.        //在找到的工作线程对象中创建一个Track,注意它的类型是Track
  31.        track = thread->createTrack_l(client, streamType, sampleRate, format,
  32.                channelCount, frameCount, sharedBuffer, &lStatus);
  33.    }
  34.    /*
  35.     TrackHandle是Track对象的Proxy，它支持Binder通信，而Track不支持Binder
  36.     TrackHandle所接收的请求最终会由Track处理，这是典型的Proxy模式
  37.    */
  38.    trackHandle= new TrackHandle(track);
  39.    return trackHandle;
  40. }

这个函数相当复杂，主要原因之一，是其中出现了几个我们没接触过的类。先进入checkPlaybackThread_l看看。
（1） 选择工作线程
checkPlaybackThread_l的代码如下所示：
[-->AudioFlinger.cpp]

  1. AudioFlinger::PlaybackThread* AudioFlinger::checkPlaybackThread_l(int output) const
  2. {
  3.     PlaybackThread*thread = NULL;
  4.     //根据output的值找到对应的thread
  5.     if(mPlaybackThreads.indexOfKey(output) >= 0) {
  6.        thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get();
  7.     }
  8.     return thread;
  9. }

上面函数中传入的output，就是之前在分析AT时提到的工作线程索引号。看到这里，是否感觉有点困惑？困惑的原因可能有二：
·  目前的流程中尚没有见到创建线程的地方，但在这里确实能找到一个线程。
·  Output含义到底是什么？为什么会把它作为index来找线程呢？
关于这两个问题，待会儿再做解释。现在只需知道AudioFlinger会创建几个工作线程，AT会找到对应的工作线程即可。
（2） createTrack_l的分析
找到工作线程后，会执行createTrack_l函数，请看这个函数的作用：
[-->AudioFlinger.cpp]

  1. // Android的很多代码都采用了内部类的方式进行封装，看习惯就好了
  2. sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
  3.        const sp<AudioFlinger::Client>& client,int streamType,
  4.        uint32_t sampleRate,int format,int channelCount,int frameCount,
  5.        const sp<IMemory>& sharedBuffer,//注意这个参数，从AT中传入，为0
  6.        status_t *status)
  7. {
  8.    sp<Track> track;
  9.    status_t lStatus;
  10.    {
  11.       Mutex::Autolock _l(mLock);
  12.       //创建Track对象
  13.       track= new Track(this, client, streamType, sampleRate, format,
  14.                       channelCount, frameCount, sharedBuffer);
  15.       //将新创建的Track加入到内部数组mTracks中
  16.       mTracks.add(track);
  17.    }
  18.    lStatus= NO_ERROR;
  19.    return track;
  20. }

上面的函数调用传入的sharedBuffer为空，那共享内存又是在哪里创建的呢？可以注意到Track构造函数关于sharedBuffer这个参数的类型是一个引用，莫非是构造函数创建的？
（3） Track创建共享内存和TrackHandle
在createTrack_l中，会new出来一个Track，请看它的代码：
[-->AudioFlinger.cpp]

  1. AudioFlinger::PlaybackThread::Track::Track(const wp<ThreadBase>& thread,
  2.             const sp<Client>& client,int streamType,uint32_t sampleRate,
  3.             int format,int channelCount,int frameCount,
  4.             const sp<IMemory>& sharedBuffer)
  5. :  TrackBase(thread, client, sampleRate, format, channelCount,
  6.     frameCount,0, sharedBuffer),//sharedBuffer仍然为空
  7.    mMute(false), mSharedBuffer(sharedBuffer), mName(-1)
  8. {
  9.    // mCblk!=NULL? 什么时候创建的呢？只能看基类TrackBase的构造函数了
  10.    if(mCblk != NULL) {
  11.       mVolume[0] = 1.0f;
  12.       mVolume[1] = 1.0f;
  13.       mStreamType = streamType;
  14.       mCblk->frameSize = AudioSystem::isLinearPCM(format) ?
  15.                               channelCount * sizeof(int16_t): sizeof(int8_t);
  16.     }
  17. }

对于这种重重继承，我们只能步步深入分析，一定要找到共享内存创建的地方，继续看代码：
[-->AudioFlinger.cpp]

  1. AudioFlinger::ThreadBase::TrackBase::TrackBase(
  2.            const wp<ThreadBase>& thread,const sp<Client>&client,
  3.            uint32_t sampleRate,int format,int channelCount,int frameCount,
  4.            uint32_t flags,const sp<IMemory>& sharedBuffer)
  5.     :   RefBase(), mThread(thread),mClient(client),mCblk(0),
  6.         mFrameCount(0),mState(IDLE),mClientTid(-1),mFormat(format),
  7.         mFlags(flags & ~SYSTEM_FLAGS_MASK)
  8. {
  9.     size_t size = sizeof(audio_track_cblk_t);//得到CB对象大小
  10.     //计算数据缓冲大小
  11.     size_t bufferSize = frameCount*channelCount*sizeof(int16_t);
  12.     if(sharedBuffer == 0) {
  13.       //还记得图7-4吗？共享内存最前面一部分是audio_track_cblk_t，后面才是数据空间
  14.       size+= bufferSize;
  15.     }
  16.     //根据size创建一块共享内存。
  17.     mCblkMemory = client->heap()->allocate(size);
  18.     /*
  19.       pointer()返回共享内存的首地址， 并强制转换void*类型为audio_track_cblk_t*类型。
  20.       其实把它强制转换成任何类型都可以，但是这块内存中会有CB对象吗？
  21.     */
  22.     mCblk= static_cast<audio_track_cblk_t *>(mCblkMemory->pointer());
  23.     //1 下面这句代码看起来很独特。什么意思？？？
  24.     new(mCblk)audio_track_cblk_t();
  25.     mCblk->frameCount = frameCount;
  26.     mCblk->sampleRate = sampleRate;
  27.     mCblk->channels = (uint8_t)channelCount;
  28.     if (sharedBuffer == 0) {
  29.       //清空数据区
  30.       mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
  31.       memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));
  32.       // flowControlFlag初始值为1
  33.       mCblk->flowControlFlag = 1;
  34.     }
  35.     //mBuffer与sharedBuffer有关系吧，共享内存通过sharedBuffer引用传出去了?
  36.     ......
  37. }

这里需要重点讲解下面这句话的意思。

new(mCblk) audio_track_cblk_t();

注意它的用法，new后面的括号里是内存，紧接其后的是一个类的构造函数。
重点说明：这个语句就是C++语言中的placement new。其含义是在括号里指定的内存中创建一个对象。我们知道，普通的new只能在堆上创建对象，堆的地址由系统分配。这里采用placementnew将使得audio_track_cblk_t创建在共享内存上，它就自然而然地能被多个进程看见并使用了。关于placementnew较详细的知识，还请读者自己搜索一下。
通过上面的分析，可以知道：
·  Track创建了共享内存。
·  CB对象通过placement new方法创建于这块共享内存中。
AF的createTrack函数返回的是一个IAudioTrack类型的对象，可现在碰到的Track对象是IAudioTrack类型吗？来看代码：
[-->AudioFlinger.cpp]

  1. sp<IAudioTrack> AudioFlinger::createTrack（......）
  2. {
  3.     sp<TrackHandle>trackHandle;
  4.     ......
  5.     track= thread->createTrack_l(client, streamType, sampleRate,
  6.                     format,channelCount,frameCount, sharedBuffer, &lStatus);
  7.     trackHandle= new TrackHandle(track);
  8.     return trackHandle;//1 这个trackHandle对象竟然没有在AF中保存！
  9. }

原来，createTrack返回的是TrackHandle对象，它以Track为参数构造。这二者之间又是什么关系呢？
Android在这里使用了Proxy模式，即TrackHandle是Track的代理，TrackHandle代理的内容是什么呢？分析TrackHandle的定义可以知道：
·  Track没有基于Binder通信，它不能接收来自远端进程的请求。
·  TrackHandle能基于Binder通信，它可以接收来自远端进程的请求，并且能调用Track对应的函数。这就是Proxy模式的意思。
讨论：Android为什么不直接让Track从IBinder派生，直接支持Binder通信呢？关于这个问题，在看到后面的Track家族图谱后，我们或许就明白了。
另外，注意代码中的注释1：
·  trackHandle被new出来后直接返回，而AF中并没有保存它，这岂不是成了令人闻之色变的野指针？
拓展思考：关于这个问题的答案，请读者自己思考并回答。提示，可从Binder和RefBase入手。
分析完createTrack后，估计有些人会晕头转向的。确实，这个createTrack比较复杂。仅对象类型就层出不穷。到底它有多少种对象，它们之间又有怎样的关系呢？下面就来解决这几个问题。

2. 到底有多少种对象？

不妨把AudioFlinger中出现的对象总结一下，以了解它们的作用和相互之间的关系。
（1） AudioFlinger对象
作为Audio系统的核心引擎，首先要介绍AudioFlinger。AudioFlinger的主要工作由其定义的许多内部类来完成，我们用图7来表示。图中大括号所指向的类为外部类，大括号所包含的为该外部类所定义的内部类。例如，DuplicatingThread、RecordThread和DirectOutputThread都包括在一个大括号中，这个大括号指向AudioFlinger，所以它们三个都是AudioFlinger的内部类，而AudioFlinger则是它们三个的外部类：

图7  AF中的所有类

（2） Client对象
Client是AudioFlinger对客户端的封装，凡是使用了AudioTrack和AudioRecord的进程，都被会当做是AF的Client，并且Client用它的进程pid作为标识。代码如下所示：

  1. class Client : public RefBase {
  2.    public:
  3.         Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
  4.         virtual             ~Client();
  5.         const sp<MemoryDealer>&    heap() const;
  6.         pid_t               pid() const {return mPid; }
  7.         sp<AudioFlinger>    audioFlinger() { return mAudioFlinger; }
  8.    private:
  9.         Client(constClient&);
  10.         Client&operator = (const Client&);
  11.         sp<AudioFlinger>   mAudioFlinger;
  12.         sp<MemoryDealer>   mMemoryDealer;//内存分配器
  13.         pid_t              mPid;
  14. };

注意：一个Client进程可以创建多个AudioTrack，这些AudioTrack都属于一个Client。
（3） 工作线程介绍
AudioFlinger中有几种不同类型的工作线程，它们之间的关系如图8所示：

图8  AF中的工作线程家谱
下面来解释图8中各种类型工作线程的作用：
PlaybackThread：回放线程，用于音频输出。它有一个成员变量mOutput，为AudioStreamOutput*类型，这表明PlaybackThread直接和Audio音频输出设备建立了联系。
·  RecordThread：录音线程，用于音频输入，它的关系比较单纯。它有一个成员变量mInput为AudioStreamInput*类型，这表明RecordThread直接和Audio音频输入设备建立了联系。
从PlaybackThread的派生关系上可看出，手机上的音频回放应该比较复杂，否则也不会派生出三个子类了。其中：
·  MixerThread：混音线程，它将来自多个源的音频数据混音后再输出。
·  DirectOutputThread：直接输出线程，它会选择一路音频流后将数据直接输出，由于没有混音的操作，这样可以减少很多延时。
·  DuplicatingThread：多路输出线程，它从MixerThread派生，意味着它也能够混音。它最终会把混音后的数据写到多个输出中，也就是一份数据会有多个接收者。这就是Duplicate的含义。目前在蓝牙A2DP设备输出中使用。
另外从图8中还可以看出：
PlaybackThread维护两个Track数组，一个是mActiveTracks，表示当前活跃的Track，一个是mTracks，表示这个线程创建的所有Track。
·  DuplicatingThread还维护了一个mOutputTracks，表示多路输出的目的端。后面分析DuplicatingThread时再对此进行讲解。
说明：大部分常见音频输出使用的是MixerThread，后文会对此进行详细分析。另外，在拓展内容中，也将深入分析DuplicatingThread的实现。

（4） PlaybackThread和AudioStreamOutput
从图8中，可以发现一个PlaybackThread有一个AudioStreamOutput类型的对象，这个对象提供了音频数据输出功能。可以用图9来表示音频数据的流动轨迹。该图以PlaybackThread最常用的子类MixerThread作为代表。

图9  音频数据的流动轨迹
根据图9，就能明白MixerThread的大致工作流程：
·  接收来自AT的数据。
·  对这些数据进行混音。
·  把混音的结果写到AudioStreamOut，这样就完成了音频数据的输出。
（5） Track对象
前面所说的工作线程，其工作就是围绕Track展开的，图10展示了Track的家族：
注意：这里把RecordTrack也统称为Track。

图10  Track家族
从图10中可看出，TrackHandle和RecordHandle是基于Binder通信的，它作为Proxy，用于接收请求并派发给对应的Track和RecordTrack。从图10也能看出，之所以不让Track继承Binder框架，是因为Track本身的继承关系和所承担的工作已经很复杂了，如再让它掺合Binder，只会乱上添乱。
Track类作为工作线程的内部类来实现，其中：
·  TrackBase定义于ThreadBase中。
·  Track定义于PlaybackThread中，RecordTrack定义于RecordThread中。
·  OutputTrack定义于DuplicatingThread中。
根据前面的介绍可知，音频输出数据最后由Playback线程来处理，用例所对应的Playback线程，实际上是一个MixerThread，那么它是如何工作的呢？一起来分析。

3. MixerThread分析

MixerThread是Audio系统中负担最重的一个工作线程。先来了解一下它的来历。
（1） MixerThread的来历
前面，在checkplaybackThread_l中，有一个地方一直没来得及解释。回顾一下它的代码：
[-->AudioFlinger.cpp]

  1. AudioFlinger::PlaybackThread *
  2.         AudioFlinger::checkPlaybackThread_l(intoutput) const
  3. {
  4.   PlaybackThread*thread = NULL;
  5.   //根据output的值找到对应的thread
  6.   if(mPlaybackThreads.indexOfKey(output) >= 0) {
  7.       thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get();
  8.   }
  9.   return thread;
  10. }

上面这个函数的意思很明确：就是根据output值找到对应的回放线程。
但在前面的流程分析中，并没有见到创建线程的地方，那这个线程又是如何得来的？它又是何时、怎样创建的呢？
答案在AudioPolicyService中。提前看看AudioPolicyService，分析一下，它为什么和这个线程有关系。
AudioPolicyService和AudioFlinger一样，都驻留在MediaServer中，直接看它的构造函数：
[-->AudioPolicyService.cpp]

  1. AudioPolicyService::AudioPolicyService()
  2.     :BnAudioPolicyService() , mpPolicyManager(NULL)
  3. {
  4.     char value[PROPERTY_VALUE_MAX];
  5.     // Tone音播放线程
  6.     mTonePlaybackThread = new AudioCommandThread(String8(""));
  7.     // 命令处理线程
  8.     mAudioCommandThread = new AudioCommandThread(String8("ApmCommandThread"));
  9. #if (defined GENERIC_AUDIO) || (defined AUDIO_POLICY_TEST)
  10.     //这里属于Generic的情况，所以构造AudioPolicyManagerBase，注意构造函数的参数
  11.     mpPolicyManager = new AudioPolicyManagerBase(this);
  12. #else
  13.     ......
  14.     //创建和硬件厂商相关的AudioPolicyManager
  15. #endif
  16.     ......
  17. }

看AudioPolicyManagerBase的构造函数，注意传给它的参数是this，即把AudioPolicyService对象传进去了。
[-->AudioPolicyManagerBase.cpp]

  1. AudioPolicyManagerBase::AudioPolicyManagerBase(
  2.            AudioPolicyClientInterface*clientInterface)
  3.         :mPhoneState(AudioSystem::MODE_NORMAL), mRingerMode(0),
  4.          mMusicStopTime(0),mLimitRingtoneVolume(false)
  5. {
  6.     mpClientInterface = clientInterface;
  7.     // 先把不相关的内容去掉
  8.     ......
  9.     /*
  10.       返回来调用mpClientInterface的openOutput，实际就是AudioPolicyService。
  11.       注意openOutput函数是在AP的创建过程中调用的
  12.     */
  13.     mHardwareOutput =mpClientInterface->openOutput(&outputDesc->mDevice,
  14.                                     &outputDesc->mSamplingRate,
  15.                                     &outputDesc->mFormat,
  16.                                     &outputDesc->mChannels,
  17.                                     &outputDesc->mLatency,
  18.                                     outputDesc->mFlags);
  19.     ......
  20. }

还得回到AudioPolicyService中去看看：
[-->AudioPolicyService.cpp]

  1. audio_io_handle_t AudioPolicyService::openOutput(uint32_t *pDevices,
  2.                                 uint32_t*pSamplingRate,
  3.                                 uint32_t*pFormat,
  4.                                 uint32_t*pChannels,
  5.                                 uint32_t*pLatencyMs,
  6.                                 AudioSystem::output_flags flags)
  7. {
  8.   //BpAudioFlinger,binder也支持进程内通信?
  9.   sp<IAudioFlinger>af = AudioSystem::get_audio_flinger();
  10.   //下面会调用AudioFlinger的openOutput，这个时候AF已经启动了
  11.   return af->openOutput(pDevices, pSamplingRate, (uint32_t *)pFormat,
  12.                           pChannels, pLatencyMs,flags);
  13. }

又得到AF去看看：
[-->AudioFlinger.cpp]

  1. int AudioFlinger::openOutput(uint32_t *pDevices,uint32_t*pSamplingRate,uint32_t *pFormat,
  2.        uint32_t*pChannels,uint32_t *pLatencyMs,uint32_t flags)
  3. {
  4.    ......
  5.    Mutex::Autolock _l(mLock);
  6.    //创建Audio HAL的音频输出对象，和音频输出扯上了关系
  7.    AudioStreamOut *output = mAudioHardware->openOutputStream(*pDevices,
  8.                                                             (int *)&format,
  9.                                                             &channels,
  10.                                                             &samplingRate,
  11.                                                             &status);
  12.    mHardwareStatus = AUDIO_HW_IDLE;
  13.    if(output != 0) {
  14.         if((flags & AudioSystem::OUTPUT_FLAG_DIRECT) ||
  15.            (format != AudioSystem::PCM_16_BIT) ||
  16.            (channels != AudioSystem::CHANNEL_OUT_STEREO)) {
  17.            //如果标志为OUTPUT_FLAG_DIRECT,则创建DirectOutputThread
  18.            thread = new DirectOutputThread(this, output, ++mNextThreadId);
  19.         } else {
  20.           //一般创建的都是MixerThread，注意代表AudioStreamOut对象的output也传进去了
  21.           thread= new MixerThread(this, output, ++mNextThreadId);
  22.         }
  23.         //把新创建的线程加入线程组mPlaybackThreads中保存, mNextThreadId是它的索引号
  24.         mPlaybackThreads.add(mNextThreadId, thread);
  25.         ......
  26.         return mNextThreadId;//返回该线程的索引号
  27.    }
  28.    return 0;
  29. }

可用一个简单的示意图来观察三者的交互流程，如图11所示：

图11  MixerThread的来历示意图
图11表明：
·  AF中的工作线程的创建，受到了AudioPolicyService的控制。从AudioPolicyService的角度出发，这也是应该的，因为APS控制着整个音频系统，而AF只是管理音频的输入和输出。
·  另外，注意这个线程是在AP的创建过程中产生的。也就是说，AP一旦创建完Audio系统，就已经准备好工作了。
关于AF和AP的恩恩怨怨，在后面APS的分析过程中再去探讨。目前，读者只需了解系统中第一个MixerThread的来历即可。下面来分析这个来之不易的MixerThread。
（2） MixerThread的构造和线程启动
[-->AudioFlinger.cpp]

  1. AudioFlinger::MixerThread::MixerThread(
  2.         constsp<AudioFlinger>& audioFlinger,
  3.         AudioStreamOut* output, // AudioStreamOut为音频输出设备的HAL抽象
  4.         intid)
  5.      :  PlaybackThread(audioFlinger, output, id),mAudioMixer(0)
  6. {
  7.    mType = PlaybackThread::MIXER;
  8.    //混音器对象，这个对象比较复杂，它完成多路音频数据的混合工作
  9.    mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);
  10. }

再来看MixerThread的基类PlaybackThread的构造函数：

[-->AudioFlinger.cpp]

  1. AudioFlinger::PlaybackThread::PlaybackThread(constsp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id)
  2.         : ThreadBase(audioFlinger, id),
  3.           mMixBuffer(0),mSuspended(0), mBytesWritten(0),
  4.           mOutput(output), mLastWriteTime(0),mNumWrites(0),
  5.           mNumDelayedWrites(0), mInWrite(false)
  6. {
  7.     //获取音频输出HAL对象的一些信息，包括硬件中音频缓冲区的大小（以帧为单位）
  8.     readOutputParameters();
  9.     mMasterVolume= mAudioFlinger->masterVolume();
  10.     mMasterMute= mAudioFlinger->masterMute();
  11.     //设置不同类型音频流的音量及静音情况
  12.     for(int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++)
  13.     {
  14.         mStreamTypes[stream].volume = mAudioFlinger->streamVolumeInternal(stream);
  15.         mStreamTypes[stream].mute = mAudioFlinger->streamMute(stream);
  16.     }
  17.   //发送一个通知消息给监听者，这部分内容较简单，读者可自行研究
  18.   sendConfigEvent(AudioSystem::OUTPUT_OPENED);
  19. }

此时，线程对象已经创建完毕。根据对Thread的分析，应该调用它的run函数才能真正创建新线程。在首次创建sp时调用了run，这里利用了RefBase的onFirstRef函数。根据MixerThread的派生关系，该函数最终由父类PlaybackThread的onFirstRef实现：

[-->AudioFlinger.cpp]

  1. void AudioFlinger::PlaybackThread::onFirstRef()
  2. {
  3.     const size_t SIZE = 256;
  4.     char buffer[SIZE];
  5.     snprintf(buffer, SIZE, "Playback Thread %p", this);
  6.     //下面的run就真正创建了线程并开始执行threadLoop
  7.     run(buffer, ANDROID_PRIORITY_URGENT_AUDIO);
  8. }

好，线程已经run起来了。继续按流程分析，下一个轮到的调用函数是start。

4. start的分析

AT调用的是IAudioTrack的start函数，由于TrackHandle的代理作用，这个函数的实际处理会由Track对象来完成。
[-->AudioFlinger.cpp]

  1. status_tAudioFlinger::PlaybackThread::Track::start()
  2. {
  3.     status_t status = NO_ERROR;
  4.     sp<ThreadBase> thread = mThread.promote();
  5.  
  6.     //该Thread是用例中的MixerThread
  7.     if(thread != 0) {
  8.        Mutex::Autolock _l(thread->mLock);
  9.        int state = mState;
  10.         if (mState == PAUSED) {
  11.            mState = TrackBase::RESUMING;
  12.           } else {
  13.            mState = TrackBase::ACTIVE;//设置Track的状态
  14.         }
  15.         PlaybackThread *playbackThread =(PlaybackThread *)thread.get();
  16.         //addTrack_l把这个track加入到mActiveTracks数组中
  17.         playbackThread->addTrack_l(this);
  18.     return status;
  19. }

看看这个addTrack_l函数，代码如下所示：
[-->AudioFlinger.cpp]

  1. status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
  2. {
  3.     status_t status = ALREADY_EXISTS;
  4.     //1 mRetryCount：设置重试次数，kMaxTrackStartupRetries值为50
  5.     track->mRetryCount = kMaxTrackStartupRetries;
  6.     if(mActiveTracks.indexOf(track) < 0) {
  7.       //2 mFillingUpStatus：缓冲状态
  8.       track->mFillingUpStatus= Track::FS_FILLING;
  9.       //原来是把调用start的这个track加入到活跃的Track数组中了
  10.       mActiveTracks.add(track);
  11.       status = NO_ERROR;
  12.    }
  13.    //广播一个事件，一定会触发MixerThread线程，通知它有活跃数组加入，需要开工干活
  14.    mWaitWorkCV.broadcast();
  15.    return status;
  16. }

start函数把这个Track加入到活跃数组后，将触发一个同步事件，这个事件会让工作线程动起来。虽然这个函数很简单，但有两个关键点必须指出，这两个关键点其实指出了两个问题的处理办法：
·  mRetryCount表示重试次数，它针对的是这样一个问题：如果一个Track调用了start却没有write数据，该怎么办？如果MixerThread尝试了mRetryCount次后还没有可读数据，工作线程就会把该Track从激活队列中去掉了。
·  mFillingUpStatus能解决这样的问题：假设分配了1MB的数据缓冲，那么至少需要写多少数据的工作线程才会让Track觉得AT是真的需要它工作呢？难道AT写一个字节就需要工作线程兴师动众吗？其实，这个状态最初为Track::FS_FILLING，表示正在填充数据缓冲。在这种状态下，除非AT设置了强制读数据标志（CB对象中的forceReady变量），否则工作线程是不会读取该Track的数据的。该状态还有其他的值，读者可以自行研究。
说明：我们在介绍大流程的同时也把一些细节问题指出来，希望这些细节问题能激发读者深入研究的欲望。
Track加入了工作线程的活跃数组后，又触发了一个同步事件，MixerThread是否真的动起来了呢？一起来看：
（1） MixerThread动起来
Thread类的线程工作都是在threadLoop中完成的，那么MixerThread的线程又会做什么呢？
[-->AudioFlinger.cpp]

  1. bool AudioFlinger::MixerThread::threadLoop()
  2. {
  3.     int16_t* curBuf = mMixBuffer;
  4.     Vector< sp<Track> > tracksToRemove;
  5.     uint32_t mixerStatus = MIXER_IDLE;
  6.     nsecs_t standbyTime = systemTime();
  7.     ......
  8.     uint32_t sleepTime = idleSleepTime;
  9.     while(!exitPending())
  10.     {
  11.         //1 处理一些请求和通知消息，如之前在构造函数中发出的OUTPUT_OPEN消息等
  12.         processConfigEvents();
  13.         mixerStatus = MIXER_IDLE;
  14.         {  // scope for mLock
  15.            Mutex::Autolock _l(mLock);
  16.            //检查配置参数，如有需要则重新设置内部参数值
  17.            if (checkForNewParameters_l()) {
  18.                mixBufferSize = mFrameCount * mFrameSize;
  19.                maxPeriod = seconds(mFrameCount) / mSampleRate * 3;
  20.                ......
  21.            }
  22.            //获得当前的已激活track数组
  23.            const SortedVector< wp<Track> >& activeTracks =mActiveTracks;
  24.             ......
  25.            /*
  26.            2 prepareTracks_l将检查mActiveTracks数组，判断是否有AT的数据需要处理。
  27.            例如有些AudioTrack虽然调用了start，但是没有及时write数据，这时就无须进行混音工作。我们待会再分析prepareTracks_l函数
  28.           */
  29.            mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);
  30.        }
  31.         //MIXER_TRACKS_READY表示AT已经把数据准备好了
  32.         if(LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
  33.            //3 由混音对象进行混音工作，混音的结果放在curBuf中
  34.            mAudioMixer->process(curBuf);
  35.            sleepTime = 0;//等待时间设置为零，表示需要马上输出到Audio HAL
  36.            standbyTime = systemTime() + kStandbyTimeInNsecs;
  37.         }
  38.         .......
  39.         if(sleepTime == 0) {
  40.            ......
  41.            //4 往Audio HAL的OutputStream中write混音后的数据，这是音频数据的最终归宿
  42.            int bytesWritten = (int)mOutput->write(curBuf, mixBufferSize);
  43.            if (bytesWritten < 0) mBytesWritten -= mixBufferSize;
  44.            ......
  45.            mStandby = false;
  46.         }else {
  47.            usleep(sleepTime);
  48.         }
  49.         tracksToRemove.clear();
  50.     }
  51.     if(!mStandby) {
  52.        mOutput->standby();
  53.     }
  54.     return false;
  55. }

从上面的分析可以看出，MixerThread的线程函数大致工作流程是：
·  如果有通知信息或配置请求，则先完成这些工作。比如向监听者通知AF的一些信息，或者根据配置请求进行音量控制，声音设备切换等。
·  调用prepareTracks _l函数，检查活跃Tracks是否有数据准备好。
·  调用混音器对象mAudioMixer的process，并且传入一个存储结果数据的缓冲，混音后的结果就存储在这个缓冲中。
·  调用代表音频输出设备的AudioOutputStream对象的write，把结果数据写入设备。
其中，配置请求处理的工作将在AudioPolicyService的分析中，以一个耳机插入处理实例进行讲解。这里主要分析代码中2 3两个步骤。
（2） prepareTracks_l和process分析
prepareTracks_l函数检查激活Track数组，看看其中是否有数据等待使用，代码如下所示：
[-->AudioFlinger.cpp]

  1. uint32_t AudioFlinger::MixerThread::prepareTracks_l(
  2.                          constSortedVector<wp<Track>>& activeTracks,
  3.                          Vector<sp<Track>>*tracksToRemove)
  4. {
  5.     uint32_t mixerStatus = MIXER_IDLE;
  6.     //激活Track的个数
  7.     size_tcount = activeTracks.size();
  8.     float masterVolume = mMasterVolume;
  9.     bool  masterMute = mMasterMute;
  10.     //依次查询这些Track的情况
  11.     for(size_t i=0 ; i<count ; i++) {
  12.        sp<Track> t = activeTracks[i].promote();
  13.        if(t == 0) continue;
  14.        Track* const track = t.get();
  15.        //怎么查？通过audio_track_cblk_t对象
  16.        audio_track_cblk_t* cblk = track->cblk();
  17.        /*
  18.         一个混音器可支持32个Track，它内部有一个32元素的数组，name函数返回的就是Track在
  19.         这个数组中的索引。混音器每次通过setActiveTrack设置一个活跃Track，后续所有操作都会针对当前设置的这个活跃Track
  20.        */
  21.        mAudioMixer->setActiveTrack(track->name());
  22.        //下面这个判断语句决定了什么情况下Track数据可用
  23.        if (cblk->framesReady() &&(track->isReady() || track->isStopped())
  24.              && !track->isPaused()&& !track->isTerminated())
  25.        {
  26.             ......
  27.            /*
  28.             设置活跃Track的数据提供者为Track本身，因为Track从AudioBufferProvider
  29.             派生。混音器工作时，需从Track得到待混音的数据，也就是AT写入的数据由混音器取出并消费
  30.            */
  31.            mAudioMixer->setBufferProvider(track);
  32.            //设置对应Track的混音标志
  33.            mAudioMixer->enable(AudioMixer::MIXING);
  34.            ......
  35.            //设置该Track的音量等信息，这在以后的混音操作中会使用
  36.            mAudioMixer->setParameter(param, AudioMixer::VOLUME0, left);
  37.            mAudioMixer->setParameter(param,AudioMixer::VOLUME1, right);
  38.            mAudioMixer->setParameter(
  39.                AudioMixer::TRACK,
  40.                AudioMixer::FORMAT, track->format());
  41.            ......
  42.            mixerStatus = MIXER_TRACKS_READY;
  43.         }else {//如果不满足上面的条件，则走else分支
  44.            if (track->isStopped()) {
  45.                track->reset();//reset会清零读写位置，表示没有可读数据
  46.            }
  47.            //如果处于这三种状态之一，则加入移除队列
  48.            if (track->isTerminated() || track->isStopped() || track->isPaused()) {
  49.                tracksToRemove->add(track);
  50.                mAudioMixer->disable(AudioMixer::MIXING);
  51.            } else {
  52.              //不处于上面三种状态时，表示暂时没有可读数据，则重试mRetryCount次
  53.              if (--(track->mRetryCount) <= 0) {
  54.                  tracksToRemove->add(track);
  55.              } else if (mixerStatus != MIXER_TRACKS_READY) {
  56.                  mixerStatus =MIXER_TRACKS_ENABLED;
  57.              }
  58.              //禁止这个Track的混音
  59.              mAudioMixer->disable(AudioMixer::MIXING);
  60.             ......
  61.            }
  62.        }
  63.     }
  64.     //对那些被移除的Track做最后的处理
  65.     ......
  66.     return mixerStatus;
  67. }

当所有Track准备就绪后，最重要的工作就是混音。混音对象的process就派上了用场。来看这个process函数，代码如下所示：
[-->AudioMixer.cpp]

  1. void AudioMixer::process(void* output)
  2. {
  3.    mState.hook(&mState, output);//hook？这是一个函数指针
  4. }

hook是函数指针，它根据Track的个数和它的音频数据格式（采样率等）等情况，使用不同的处理函数。为进一步了解混音器是如何工作的，需要先分析AudioMixer对象。
（3） AudioMixer对象的分析
AudioMixer实现AudioMixer.cpp中，先看构造函数：
[-->AudioMixer.cpp]

  1. AudioMixer::AudioMixer(size_t frameCount,uint32_t sampleRate)
  2.     :   mActiveTrack(0), mTrackNames(0),mSampleRate(sampleRate)
  3. {
  4.     mState.enabledTracks= 0;
  5.     mState.needsChanged = 0;
  6.     mState.frameCount   = frameCount;//这个值等于音频输出对象的缓冲大小
  7.     mState.outputTemp   = 0;
  8.     mState.resampleTemp= 0;
  9.     //hook初始化的时候为process__nop，这个函数什么都不会做
  10.     mState.hook = process__nop;
  11.     track_t*t = mState.tracks;//track_t是和Track相对应的一个结构
  12.     //最大支持32路混音，也很不错了
  13.     for(int i=0 ; i<32 ; i++) {
  14.        ......
  15.        t->channelCount = 2;
  16.        t->enabled = 0;
  17.        t->format = 16;
  18.        t->buffer.raw = 0;
  19.        t->bufferProvider = 0; // bufferProvider为这一路Track的数据提供者
  20.        t->hook = 0;//每一个Track也有一个hook函数
  21.        ......
  22.     }
  23. }

其中，mState是在AudioMixer类中定义的一个数据结构。

  1. struct state_t {
  2.        uint32_t        enabledTracks;
  3.        uint32_t        needsChanged;
  4.        size_t          frameCount;
  5.        mix_t           hook;
  6.        int32_t         *outputTemp;
  7.        int32_t         *resampleTemp;
  8.        int32_t         reserved[2];
  9.        /*
  10.         aligned表示32字节对齐
  11.        */   
  12.        track_t         tracks[32]; __attribute__((aligned(32)));
  13. };

AudioMixer为hook准备了多个实现函数，来看：
·  process__validate：根据Track的格式、数量等信息选择其他的处理函数。
·  process__nop：什么都不做。
·  process__genericNoResampling：普通无需重采样。
·  process__genericResampling：普通需重采样。
·  process__OneTrack16BitsStereoNoResampling：一路音频流，双声道，PCM16格式，无需重采样。
·  process__TwoTracks16BitsStereoNoResampling：两路音频流，双声道，PCM16格式，无需重采样。
hook最初的值为process__nop，这一定不会是混音中最终使用的处理函数，难道有动态赋值的地方？是的。一起来看：
（4） 杀鸡不用宰牛刀
在AF的prepareTracks_l中，会为每一个准备好的Track使能混音标志：

  1. mAudioMixer->setBufferProvider(track);
  2. mAudioMixer->enable(AudioMixer::MIXING);//使能混音

请看enable的实现：
[-->AudioMixer.cpp]

  1. status_t AudioMixer::enable(int name)
  2. {
  3.     switch(name) {
  4.        case MIXING: {
  5.            if (mState.tracks[ mActiveTrack ].enabled != 1) {
  6.                mState.tracks[ mActiveTrack ].enabled = 1;
  7.                //注意这个invalidateState调用
  8.                invalidateState(1<<mActiveTrack);
  9.            }
  10.        }break;
  11.        default:
  12.            return NAME_NOT_FOUND;
  13.     }
  14.     return NO_ERROR;
  15. }
  16.  
  17. void AudioMixer::invalidateState(uint32_t mask)
  18. {
  19.     if(mask) {
  20.        mState.needsChanged |= mask;
  21.        mState.hook = process__validate;//将hook设置为process_validate
  22.     }
  23. }

process_validate会根据当前Track的情况选择不同的处理函数，所以不会出现杀鸡却用灾牛刀的情况。
[-->AudioMixer.cpp]

  1. void AudioMixer::process__validate(state_t* state, void* output)
  2. {
  3.    uint32_t changed = state->needsChanged;
  4.    state->needsChanged = 0;
  5.    uint32_t enabled = 0;
  6.    uint32_t disabled = 0;
  7.    ......
  8.    if(countActiveTracks) {
  9.         if(resampling) {
  10.            ......
  11.            //如果需要重采样，则选择process__genericResampling
  12.            state->hook = process__genericResampling;
  13.         }else {
  14.            ......
  15.            state->hook = process__genericNoResampling;
  16.            if (all16BitsStereoNoResample && !volumeRamp) {
  17.                if (countActiveTracks == 1) {
  18.                     //如果只有一个Track，则使用process__OneTrack16BitsStereoNoResampling
  19.                     state->hook =process__OneTrack16BitsStereoNoResampling;
  20.                }
  21.            }
  22.         }
  23.    }
  24.    state->hook(state, output);
  25.    ......
  26. }

假设用例运行时，系统只有这么一个Track，那么hook函数使用的就是process__OneTrack16BitsStereoNoResampling处理。process_XXX函数会涉及很多数字音频处理的专业知识，先不用去讨论它。数据缓冲的消费工作是在这个函数中完成的，因此应重点关注它是如何通过CB对象使用数据缓冲的。
说明：在这个数据消费和之前破解AT的过程中所讲的数据生产是对应的，先来提炼AT和AF在生产和消费这两个环节上与CB交互的流程。
（5） 怎么消费数据
在AudioTrack中，曾讲到数据的生产流程：
·  ObtainBuffer，得到一块数据缓冲。
·  memcpy数据到该缓冲。
·  releaseBuffer，释放这个缓冲。
那么做为消费者，AudioFlinger是怎么获得这些数据的呢？
[-->AudioMixer.cpp]

  1. void AudioMixer::process__OneTrack16BitsStereoNoResampling(state_t*state, void* output)
  2. {
  3.    //找到被激活的Track，此时只能有一个Track，否则就不会选择这个process函数了
  4.     const int i = 31 - __builtin_clz(state->enabledTracks);
  5.     const track_t& t = state->tracks[i];
  6.     AudioBufferProvider::Buffer& b(t.buffer);
  7.     ......
  8.     while(numFrames) {
  9.        b.frameCount = numFrames;
  10.        //BufferProvider就是Track对象，调用它的getNextBuffer获得可读数据缓冲
  11.        t.bufferProvider->getNextBuffer(&b);
  12.        int16_t const *in = b.i16;
  13.        ......
  14.        size_t outFrames = b.frameCount;
  15.        do {    //数据处理，也即是混音
  16.                uint32_t rl = *reinterpret_cast<uint32_t const *>(in);
  17.                in += 2;
  18.                int32_t l = mulRL(1, rl, vrl) >> 12;
  19.                int32_t r = mulRL(0, rl, vrl) >> 12;
  20.                //把数据复制给out缓冲
  21.                *out++ = (r<<16) | (l & 0xFFFF);
  22.            } while (--outFrames);
  23.        }
  24.        numFrames -= b.frameCount;
  25.        //调用Track的releaseBuffer释放缓冲
  26.        t.bufferProvider->releaseBuffer(&b);
  27.     }
  28. }

bufferProvider就是Track对象，总结一下它使用数据缓冲的调用流程：
·  调用Track的getNextBuffer，得到可读数据缓冲。
·  调用Track的releaseBuffer，释放数据缓冲。
现在来分析上面这两个函数：getNextBuffer和releaseBuffer。
（6） getNextBuffer和releaseBuffer的分析
先看getNextBuffer。它从数据缓冲中得到一块可读空间：
[-->AudioFlinger.cpp]

  1. status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer*buffer)
  2. {
  3.      audio_track_cblk_t*cblk = this->cblk();//通过CB对象完成
  4.      uint32_t framesReady;
  5.      //frameCount为AudioOutput音频输出对象的缓冲区大小
  6.      uint32_t framesReq = buffer->frameCount;
  7.      ......
  8.      //根据CB的读写指针计算有多少帧数据可读
  9.      framesReady = cblk->framesReady();
  10.      if (LIKELY(framesReady)){
  11.         uint32_t s = cblk->server; //当前读位置
  12.         //可读的最大位置，为当前读位置加上frameCount
  13.         uint32_tbufferEnd = cblk->serverBase + cblk->frameCount;
  14.         //AT可以通过setLooping设置播放的起点和终点，如果有终点的话，需要以loopEnd
  15.         //作为数据缓冲的末尾
  16.         bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd :bufferEnd;
  17.         if(framesReq > framesReady) {
  18.            //如果要求的读取帧数大于可读帧数，则只能选择实际可读的帧数
  19.            framesReq = framesReady;
  20.         }
  21.         //如果可读帧数的最后位置超过了AT设置的末端点，则需要重新计算可读帧数
  22.         if(s + framesReq > bufferEnd) {
  23.            framesReq = bufferEnd - s;
  24.         }
  25.         //根据读起始位置得到数据缓冲的起始地址，framesReq参数用来做内部检查，防止出错
  26.         buffer->raw = getBuffer(s, framesReq);
  27.         if (buffer->raw == 0) goto getNextBuffer_exit;
  28.         buffer->frameCount = framesReq;
  29.         return NO_ERROR;
  30.      }
  31. getNextBuffer_exit:
  32.      buffer->raw = 0;
  33.      buffer->frameCount = 0;
  34.      return NOT_ENOUGH_DATA;
  35. }

getNextBuffer非常简单，不过就是根据CB记录的读写位置等计算可读的缓冲位置。下面来看releaseBuffer的操作。
[-->AudioFlinger.cpp]

  1. void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(
  2.                  AudioBufferProvider::Buffer*buffer)
  3. {
  4.    buffer->raw = 0;
  5.    mFrameCount = buffer->frameCount;//frameCount为getNextBuffer中分配的可读帧数
  6.    step();//调用step函数
  7.    buffer->frameCount = 0;
  8. }
  9.  
  10. bool AudioFlinger::ThreadBase::TrackBase::step(){
  11.     boolresult;
  12.     audio_track_cblk_t* cblk = this->cblk();
  13.     //调用stepServer更新读位置
  14.     result= cblk->stepServer(mFrameCount);
  15.     if(!result) {
  16.        mFlags |= STEPSERVER_FAILED;
  17.     }
  18.     return result;
  19. }

getNextBuffer和releaseBuffer这两个函数相对比较简单。把它和CB交互的流程总结一下，为后面进行CB对象的分析做铺垫：
·  getNextBuffer通过frameReady得到可读帧数。
·  getBuffer函数将根据可读帧数等信息得到可读空间的首地址。
·  releaseBuffer通过stepServer更新读位置。

5. stop的分析

（1） TrackHandle和Track的回收
来自AT的stop请求最终会通过TrackHandle这个Proxy交给Track的stop处理。请直接看Track的stop：
[-->AudioFlinger.cpp]

  1. void AudioFlinger::PlaybackThread::Track::stop()
  2. {
  3.     sp<ThreadBase> thread = mThread.promote();
  4.     if(thread != 0) {
  5.        Mutex::Autolock _l(thread->mLock);
  6.        int state = mState;//保存旧的状态
  7.         if(mState > STOPPED) {
  8.            mState = STOPPED;//设置新状态为STOPPED
  9.            PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
  10.            if (playbackThread->mActiveTracks.indexOf(this) < 0) {
  11.                reset();//如果该线程的活跃数组中没有Track，则重置读写位置
  12.            }
  13.        }
  14.        //和APS相关，我们不在这里讨论，它不直接影响AudioFlinger
  15.        if(!isOutputTrack() && (state == ACTIVE || state == RESUMING)) {
  16.            thread->mLock.unlock();
  17.            AudioSystem::stopOutput(thread->id(), (AudioSystem::stream_type)mStreamType);
  18.            thread->mLock.lock();
  19.        }
  20.     }
  21. }

如果Track最初处于活跃数组，那么这个stop函数无非是把mState设置为STOPPED了，但播放该怎么停止呢？
如果仅仅调用了stop，还是会听到声音，该怎么办？在一般情况下，AT端stop后会很快被delete，这将导致AF端的TrackHandle也被delete。
说明：在介绍Track和TrackHandle一节中，曾在最后提到了那个野指针问题。相信读者这时候会知道那个问题的答案了，是吗？
看TrackHandle的析构函数：
[-->AudioFlinger.cpp]

  1. AudioFlinger::TrackHandle::~TrackHandle() {
  2.    mTrack->destroy();
  3. }
  4.  
  5. void AudioFlinger::PlaybackThread::Track::destroy()
  6. {
  7.     sp<Track> keep(this);
  8.     {
  9.         sp<ThreadBase> thread = mThread.promote();
  10.         if(thread != 0) {
  11.             if (!isOutputTrack()) {
  12.                //和AudioSystem相关，以后再分析
  13.                if (mState == ACTIVE || mState == RESUMING) {
  14.                    AudioSystem::stopOutput(thread->id(), (AudioSystem::stream_type)mStreamType);
  15.                }
  16.                AudioSystem::releaseOutput(thread->id());
  17.            }
  18.            Mutex::Autolock _l(thread->mLock);
  19.            PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
  20.            //调用回放线程对象的destroyTrack_l
  21.            playbackThread->destroyTrack_l(this);
  22.         }
  23.     }
  24. }
  25.  
  26. voidAudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
  27. {
  28.     track->mState = TrackBase::TERMINATED;//设置状态为TERMINATED
  29.     if(mActiveTracks.indexOf(track) < 0) {
  30.        mTracks.remove(track);//如果不在mActiveTracks数组中，则把它从mTracks中去掉。
  31.        //由PlaybackThread的子类实现，一般就是回收一些资源等工作
  32.        deleteTrackName_l(track->name());
  33.     }
  34. }

TrackHandle的delete最后会导致它所代理的Track对象也被删除，那么Client对象什么时候被回收呢？
（2） Client的回收
直接看TrackBase的析构，因为Track的析构会导致它的基类TrackBase析构函数被调用，代码如下所示：
[-->AudioFlinger.cpp]

  1. AudioFlinger::ThreadBase::TrackBase::~TrackBase()
  2. {
  3.     if (mCblk) {
  4.        //placement new出来的对象需要显示调用的析构函数
  5.        mCblk->~audio_track_cblk_t();
  6.        if(mClient == NULL) {
  7.            delete mCblk;//先调用析构，再释放内存，这是placement new的用法
  8.        }
  9.     }
  10.     mCblkMemory.clear();
  11.     if (mClient != NULL) {
  12.        Mutex::Autolock _l(mClient->audioFlinger()->mLock);
  13.        mClient.clear();//如果mClient的强弱引用计数都为0，则会导致该Client被delete
  14.     }
  15. }

3.3  audio_track_cblk_t的分析

前面讲解了AudioFlinger的工作方式，但AT和AF以及那个神秘的CB对象的工作原理，一直都还没能讲解。还是从AT和AF两端关于CB对象的调用流程开始分析。

1. AT端的流程

AT端作为数据的生产者，可称它为写者，它在CB对象中用user表示。它的调用流程是：
·  调用framesAvailable，看看是否有空余的可写空间。
·  调用buffer，获得写空间起始地址。
·  调用stepUser，更新user的位置。
一起来分析一下，由于这几个函数都相当简单，力争一气呵成。
先调用framesAvailable，看看当前剩余多少可写空间。假设是第一次进来，读者还在那等待数据，这样就不用考虑竞争等问题了，代码如下所示：
[-->AudioTrack.cpp::audio_track_cblk_t的framesAvailable()及相关]

  1. uint32_t audio_track_cblk_t::framesAvailable()
  2. {
  3.     Mutex::Autolock _l(lock);
  4.     return framesAvailable_l();//调用framesAvailable_l
  5. }
  6.  
  7. int32_t audio_track_cblk_t::framesAvailable_l()
  8. {
  9.     uint32_t u = this->user; //当前写者位置，此时也为0
  10.     uint32_t s = this->server; //当前读者位置，此时为0
  11.     if(out) { //对于音频输出，out为1
  12.         //由于不设置播放端点，所以loopStart是初始值INT_MAX， limit=0
  13.         uint32_t limit = (s < loopStart) ? s : loopStart;
  14.         //返回0+frameCount-0，也就是数据缓冲的全部大小。假设frameCount=1024帧   
  15.         return limit + frameCount - u;
  16.     }
  17. }

然后，调用buffer获得起始位置，buffer返回一个地址。
[-->AudioTrack.cpp]

  1. void* audio_track_cblk_t::buffer(uint32_t offset) const
  2. {
  3.    //buffers是数据缓冲的起始位置，offset是计算出来的基于userBase的偏移。
  4.    //通过这种方式巧妙地把数据缓冲当做环形缓冲来处理
  5.    return (int8_t *)this->buffers + (offset - userBase) * this->frameSize;
  6. }

当把数据写到缓冲后，调用stepUser。
[-->AudioTrack.cpp]

  1. uint32_t audio_track_cblk_t::stepUser(uint32_tframeCount)
  2. {
  3.    /*
  4.    framecount，表示写了多少帧，前面分配了1024帧，但写的数据可以比这个少。假设这一次写了512帧
  5.    */
  6.    uint32_t u = this->user;//user位置还没更新，此时u=0；
  7.    u +=frameCount;//u更新了，u=512
  8.    ......
  9.    /*
  10.    userBase还是初始值0。可惜只写了1024的一半,所以userBase加不了。
  11.    但这句话很重要，还记得前面的buffer调用吗？取数据地址的时候用offset-userBase，
  12.    一旦user位置到达缓冲的尾部，则userBase也会更新，这样offset-userBase的位置就会
  13.    回到缓冲的头部，从头到尾这么反复循环，不就是一个环形缓冲了吗？非常巧妙！
  14.    */
  15.    if (u>= userBase + this->frameCount) {
  16.      userBase += this->frameCount;
  17.    }
  18.    this->user = u;//喔，user位置也更新为512了，但是useBase还是0
  19.    return u;
  20. }

假设写者这时因某种原因停止了写数据，而读者却会被唤醒。

2  AF端的流程

AF端作为数据的消费者，它在CB中的表示是server，可称它为读者。读者的使用流程是：
·  调用framesReady看是否有可读数据。
·  获得可读数据的起始位置，这个和上面的buffer调用基本一样，都是根据offset和serverBase来获得可读数据块的首地址。
·  调用stepServer更新读位置。
现在来分析framesReady和stepServer这两个函数，framesReady的代码如下所示：
[-->AudioTrack.cpp]

  1. uint32_t audio_track_cblk_t::framesReady()
  2. {
  3.     uint32_t u = this->user; //u为512
  4.     uint32_t s = this->server;//还没读呢，s为零
  5.     if(out) {
  6.         if (u < loopEnd) {
  7.            return u - s;//loopEnd也是INT_MAX，所以这里返回512，表示有512帧可读了
  8.         } else {
  9.            Mutex::Autolock _l(lock);
  10.            if (loopCount >= 0) {
  11.                return (loopEnd - loopStart)*loopCount + u - s;
  12.            } else {
  13.                return UINT_MAX;
  14.            }
  15.         }
  16.     } else{
  17.        return s - u;
  18.     }
  19. }

可读数据地址的计算方法和前面的buffer调用一样，都是通过server和serverBase来计算的。接着看stepServer，代码如下所示：
[-->AudioTrack.cpp]

  1. bool audio_track_cblk_t::stepServer(uint32_t frameCount)
  2. {
  3.     status_t err;
  4.     err = lock.tryLock();
  5.     uint32_t s = this->server;
  6.     s += frameCount; //读了512帧了，所以s=512
  7.     ......
  8.     //没有设置循环播放，所以不走这个
  9.     if (s>= loopEnd) {
  10.        s =loopStart;
  11.         if (--loopCount == 0) {
  12.            loopEnd = UINT_MAX;
  13.            loopStart = UINT_MAX;
  14.         }
  15.     }
  16.     //和userBase一样的处理
  17.     if (s>= serverBase + this->frameCount) {
  18.        serverBase += this->frameCount;
  19.     }
  20.     this->server = s; //server为512了
  21.     cv.signal(); //读者读完了，触发一个同步信号，因为可能在等待可写的数据缓冲
  22.     lock.unlock();
  23.     return true;
  24. }

3. 真的是环形缓冲？

满足下面场景的缓冲可称为环形缓冲（假设数据缓冲最大为1024帧）：
·  写者先写1024帧，此后便无剩余空间可写。
·  读者读了前面的512帧，那么这512帧的数据空间就空余出来了。
·  所以，写者就可以重新利用这空余512帧的空间了。
关键是第三步，写者是否跟踪了读者的位置，并充分利用了读者已使用过的数据空间。所以得回头看看写者AT是否把这512帧利用了。
先看写者写完1024帧后的情况，stepUser中会有下面几句话：

  1. if (u >= userBase + this->frameCount) {
  2.     //u为1024，userBase为0，frameCount为1024
  3.     userBase += this->frameCount;//好，userBase也为1024了
  4. }

此时userBase更新为1024帧。再看写者获取可写空间的framesAvailable_l函数，按照以前的假设，应该返回512帧可写空间，代码如下所示：
[-->AudioTrack.cpp]

  1. uint32_t audio_track_cblk_t::framesAvailable_l()
  2. {
  3.     uint32_t u = this->user; //1024，写者上一次写完了整个1024帧空间
  4.     uint32_t s = this->server;//512，读者当前读到的位置
  5.     if(out) {
  6.        uint32_t limit = (s < loopStart) ? s : loopStart;
  7.        return limit + frameCount - u;//返回512
  8.     }
  9. }

framesAvailable返回了512帧，但可写空间的地址是否是从头开始的呢？要是从其他地方开始的，情况就惨了。来看buffer中最后返回的可写空间地址：

  1. //offset是外界传入的基于userBase的一个偏移量，它的值是userBase+512，所以offset-userBase将得到从头开始的那段数据空间。真的是一个环形缓冲。
  2. return (int8_t *)this->buffers + (offset -userBase) * this->frameSize;

从上面的分析中看出，CB对象通过userBase和user等几个变量，将一段有限长度的线性缓冲变成了一段无限长的缓冲，这不正是环形缓冲的精髓吗！

3.4  AudioFlinger总结

从生产者和消费者的角度来看，AF的工作还是比较简单明了：
·  MixerThread获取Track的数据，混音后写入音频输出设备。
关于AudioFlinger的学习和理解，有几个建议供大家参考：
·  首先要搞清数据传输的流程。虽然这只涉及AT和AF两个进程，但可以只在一端使用流程进行分析，例如AF的start、stop等。AT和AF的工作流程也是它们的工作步骤，流程分析在AT和AF的破解过程中起到了重要作用，希望大家能掌握这个方法。
·  搞清AF中各个类的作用和派生关系。这样，在分析时就能准确定位到具体的实现函数。
·  搞清CB对象的工作原理和方式。

4  AudioPolicyService的破解

AudioPolicyService，是和Audio策略有关的，依本人对AudioPolicy的理解，策略比流程更要复杂和难懂，对APS与对AT及AF的分析不同，因此对其不宜采用固定流程分析法，而应从下面三个步骤入手：
·  在分析AudioPolicyService的创建过程中，会讲解一些重要的概念和定义。
·  重新回到AudioTrack的分析流程，介绍其中和AudioPolicy有关的内容。
·  以一个耳机插入事件为实例，讲解AudioPolicy的处理。

4.1  AudioPolicyService的创建

AudioPolicyService和AudioFlinger都驻留于一个进程，之前在MixerThread来历一节中，曾简单介绍过APS的创建，现在需要仔细观察其中的内容。

1. 创建 AudioPolicyService

AudioPolicyService的代码如下所示：
[-->AudioPolicyService.cpp]

  1. AudioPolicyService::AudioPolicyService()
  2.         :BnAudioPolicyService() ,
  3.          mpPolicyManager(NULL)    //mpPolicyManager是Audio系统中的另一种HAL对象，它的类型是AudioPolicyInterface
  4. {
  5.      char value[PROPERTY_VALUE_MAX];
  6.      //TonePlayback用于播放Tone音，Tone包括按键音等
  7.      mTonePlaybackThread = new AudioCommandThread(String8(""));
  8.      //用于处理控制命令，例如路由切换、音量调节等
  9.      mAudioCommandThread = newAudioCommandThread(String8("ApmCommandThread"));
  10. #if (defined GENERIC_AUDIO) || (definedAUDIO_POLICY_TEST)
  11.      //注意AudioPolicyManagerBase的构造函数，把this传进去了。
  12.      mpPolicyManager = new AudioPolicyManagerBase(this);
  13. #else
  14.      ...
  15.      //使用硬件厂商实现的AudioPolicyInterface
  16.      mpPolicyManager= createAudioPolicyManager(this);
  17. #endif
  18.      //根据系统属性来判断照相机拍照时是否强制发声。为了防止偷拍，强制按快门的时候必须发出声音。
  19.      property_get("ro.camera.sound.forced",value, "0");
  20.      mpPolicyManager->setSystemProperty("ro.camera.sound.forced",value);
  21. }

和AudioFlinger中的AudioHardwareInterface一样，在APS中可以见到另外一个HAL层对象AudioPolicyInterface，为什么在APS中也会存在HAL对象呢？
如前所述，APS主要是用来控制Audio系统的，由于各个硬件厂商的控制策略不可能完全一致，所以Android把这些内容抽象成一个HAL对象。下面来看这个AudioPolicyInterface。

2. 对AudioPolicyInterface的分析

AudioPolicyInterface比AudioHardwareInterface简单直接。这里，只需看几个重点函数即可，代码如下所示：
[-->AudioPolicyInterface.h]

  1. class AudioPolicyInterface
  2. {
  3. public:
  4.     ......
  5.     //设置设备的连接状态，这些设备有耳机、蓝牙等
  6.     virtualstatus_t setDeviceConnectionState(
  7.                          AudioSystem::audio_devicesdevice,
  8.                          AudioSystem::device_connection_state state,
  9.                          const char *device_address) = 0;
  10.     //设置系统Phone状态，这些状态包括通话状态、来电状态等
  11.     virtual void setPhoneState(int state) = 0;
  12.     //设置force_use的config策略，例如通话中强制使用扬声器
  13.     virtualvoid setForceUse(AudioSystem::force_use usage,
  14.                              AudioSystem::forced_config config) = 0;
  15.     /*
  16.        audio_io_handle_t是int类型。这个函数的目的是根据传入的参数类型
  17.        找到合适的输出句柄。这个句柄，在目前的Audio系统代表AF中的某个工作线程。
  18.        还记得创建AudioTrack的时候传入的那个output值吗？它就是通过这个函数得来的。
  19.     */
  20.    virtual audio_io_handle_t getOutput(
  21.                      AudioSystem::stream_typestream,
  22.                      uint32_t samplingRate = 0,
  23.                      uint32_t format = AudioSystem::FORMAT_DEFAULT,
  24.                      uint32_t channels = 0,
  25.                      AudioSystem::output_flagsflags =
  26.                      AudioSystem::OUTPUT_FLAG_INDIRECT)= 0;
  27.    //在下面这两个函数以后会介绍。它们的第二个参数表示使用的音频流类型，
  28.    virtualstatus_t startOutput(audio_io_handle_t output,
  29.                                AudioSystem::stream_type stream) = 0;
  30.    virtual status_t stopOutput(audio_io_handle_toutput,
  31.                             AudioSystem::stream_type stream) = 0;
  32.    ......
  33.    //音量控制：设置不同音频流的音量级别范围，例如MUSIC有15个级别的音量
  34.    virtual void initStreamVolume(AudioSystem::stream_type stream,
  35.                                       intindexMin,
  36.                                       intindexMax) = 0;
  37.    //设置某个音频流类型的音量级，例如觉得music声音太小时，可以调用这个函数提高音量级
  38.    virtualstatus_t setStreamVolumeIndex(AudioSystem::stream_type stream,
  39.                                           int index) = 0;
  40. }

从上面的分析中可知，AudioPolicyInterface主要提供了一些设备切换管理和音量控制的接口。每个厂商都有各自的实现方式。目前，Audio系统提供了一个通用的实现类AudioPolicyManagerBase，以前这个类是放在hardware目录下的，现在是放到framework目录中了。图12展示了AP和HAL类之间的关系：

图12  AudioPolicy和AudioPolicyInterface的关系

其中：
·  AudioPolicyService有一个AudioPolicyInterface类型的对象。
·  AudioPolicyManagerBase有一个AudioPolicyClientInterace的对象。
AudioPolicyInterface中的一些函数后面会分析到，这些函数中有很多参数都是以AudioSystem::xxx方式出现的，那么AudioSystem又是什么呢？

3. AudioSystem的介绍

AudioSystem是一个Native类，这个类在Java层有对应的Java类，其中定义了一些重要的类型，比如音频流流程、音频设备等，这些都在AudioSystem.h中。下面来看其中的一些定义。
（1）stream type（音频流类型）
音频流类型，我们已在AudioTrack中见识过了，其完整定义如下：

  1. enum stream_type {
  2.        DEFAULT          =-1,//默认
  3.        VOICE_CALL       = 0,//通话声
  4.        SYSTEM           = 1,//系统声，例如开关机提示
  5.        RING             = 2,//来电铃声
  6.        MUSIC            = 3,//媒体播放声
  7.        ALARM            = 4,//闹钟等的警告声
  8.        NOTIFICATION     = 5,//短信等的提示声
  9.        BLUETOOTH_SCO    = 6,//蓝牙SCO
  10.        ENFORCED_AUDIBLE = 7,//强制发声，照相机的快门声就属于这个类型
  11.        DTMF             = 8,//DTMF,拨号盘的按键声
  12.        TTS              = 9,//文本转语音，Text to Speech
  13.        NUM_STREAM_TYPES
  14. };

音频流类型有什么用呢？为什么要做这种区分呢？它主要与两项内容有关：
·  设备选择：例如，之前在创建AudioTrack时，传入的音频流类型是MUSIC，当插上耳机时，这种类型的声音只会从耳机中出来，但如果音频流类型是RING，则会从耳机和扬声器中同时出来。
·  音量控制：不同流类型音量级的个数不同，例如，MUSIC类型有15个级别可供用户调节，而有些类型只有7个级别的音量。
（2）audio mode（声音模式）
audio mode和电话的状态有直接关系。先看它的定义：

  1. enum audio_mode {
  2.        MODE_INVALID = -2,
  3.        MODE_CURRENT = -1,
  4.        MODE_NORMAL = 0, //正常，既不打电话，也没有来电
  5.        MODE_RINGTONE,//有来电
  6.        MODE_IN_CALL,//通话状态
  7.        NUM_MODES
  8. };

为什么Audio需要特别强调Phone的状态呢？这必须和智能手机的硬件架构联系上。先看智能手机的硬件架构，如图13所示：

图13  智能手机的硬件架构图

从图13中看出了什么？
·  系统有一个音频DSP，声音的输入输出都要经过它（不考虑蓝牙的情况）。但它处理完的数字信号，需通过D/A（数/模）转换后输出到最终的设备上，这些设备包括扬声器、听筒、耳机等。
注意：所谓的设备切换，是指诸如扬声器切换到听筒的情况，而前面常提到的音频输出设备，应该指的是DSP。
·  系统有两个核心处理器，一个是应用处理的核心，叫AP（Application Processor），可把它当做台式机上的CPU，在这上面可以运行操作系统。另一个和手机通信相关，一般叫BP（Baseband Processor 基带处理器），可把它当做台式机上的“猫”。
·  从图13中可看出，AP和BP都能向音频DSP发送数据，它们在硬件上通路上互不干扰。于是就出现了一个问题，即如果两个P同时往DSP发送数据，而互相之间没有协调，就可能出现通话声和音乐声混杂的情况。谁还会用这样的手机？所以打电话时，将由AP上的Phone程序主动设置Audio系统的mode，在这种mode下，Audio系统会做一些处理，例如把music音量调小等。
·  注意图中的蓝牙了吗？它没有像AP那样直接和音频DSP的相连，所以音频数据需要单独发给蓝牙设备。如果某种声音要同时从蓝牙和扬声器发出，亦即一份数据要往两个地方发送，便满足了AudioFlinger中DuplicatingThread出现的现实要求。
注意：蓝牙设备实际上会建立两条数据通路：SCO和A2DP。A2DP和高质量立体声有关，且必须由AudioFlinger向它发送数据。所以“音频数据需要单独发送给蓝牙设备”，这个设备实际上是指蓝牙的A2DP设备。蓝牙技术很复杂，有兴趣的读者可以自行研究。
（3）force use和config（强制使用及配置）
大家知道，手机通话时可以选择扬声器输出，这就是强制使用的案例。Audio系统对此有很好的支持。它涉及到两个方面：
·  强制使用何种设备，例如使用扬声器、听筒、耳机等。它由forced_config控制，代码如下所示：

  1. enum forced_config {
  2.        FORCE_NONE,
  3.        FORCE_SPEAKER,  //强制使用扬声器
  4.        FORCE_HEADPHONES,
  5.        FORCE_BT_SCO,
  6.        FORCE_BT_A2DP,
  7.        FORCE_WIRED_ACCESSORY,
  8.        FORCE_BT_CAR_DOCK,
  9.        FORCE_BT_DESK_DOCK,
  10.        NUM_FORCE_CONFIG,
  11.        FORCE_DEFAULT = FORCE_NONE
  12. }

在什么情况下需要强制使用，是通话的强制使用，还是听音乐的强制使用？这须由force_use控制，代码如下所示：

  1. enum force_use {
  2.        FOR_COMMUNICATION,//通话情况，注意前缀，是FOR_XXX
  3.        FOR_MEDIA,//听音乐等媒体相关的情况
  4.        FOR_RECORD,
  5.        FOR_DOCK,
  6.        NUM_FORCE_USE
  7. }

所以，AudioPolicyInterface的setForceUse函数，就是设置在什么情况下强制使用什么设备：

  1. virtual void setForceUse(AudioSystem::force_useusage,//什么情况
  2.                           AudioSystem::forced_configconfig //什么设备
  3.                          )= 0;

（4）输出设备的定义
前面曾反复提到输出设备。这些设备在软件中是怎么表示的呢？Audio定义了很多输出设备，来看其中几个：

  1. enum audio_devices {
  2.        //output devices
  3.        DEVICE_OUT_EARPIECE = 0x1,  //听筒
  4.        DEVICE_OUT_SPEAKER = 0x2,   //扬声器
  5.        DEVICE_OUT_WIRED_HEADSET = 0x4,  //耳机
  6.        DEVICE_OUT_WIRED_HEADPHONE = 0x8, //另外一种耳机
  7.        DEVICE_OUT_BLUETOOTH_SCO = 0x10, //蓝牙相关，SCO用于通话的语音传输
  8.        DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
  9.        DEVICE_OUT_BLUETOOTH_SCO_CARKIT= 0x40,
  10.        DEVICE_OUT_BLUETOOTH_A2DP = 0x80, //蓝牙相关，A2DP用于立体声传输
  11.        DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
  12.        DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
  13.        DEVICE_OUT_AUX_DIGITAL = 0x400,
  14.        DEVICE_OUT_DEFAULT= 0x8000,
  15.        ......
  16. }

至此，AudioSystem中常用的定义都已见过了，现在要回到APS的创建上了。对这个例子，将使用Generic的设备，所以会直接创建AudioPolicyManagerBase对象，这个对象实现了AudioPolicyInterface的所有功能。一起来看。
说明：实际上很多硬件厂商实现的AudioPolicyInterface，基本上是直接使用这个AudioPolicyManagerBase。

4. AudioPolicyManagerBase的分析

AudioPolicyManagerBase类在AudioPolicyManagerBase.cpp中实现，先来看它的构造函数：
[-->AudioPolicyManagerBase.cpp]

  1. AudioPolicyManagerBase::AudioPolicyManagerBase(
  2.                           AudioPolicyClientInterface*clientInterface)
  3.                          :mPhoneState(AudioSystem::MODE_NORMAL),mRingerMode(0),
  4.                           mMusicStopTime(0),mLimitRingtoneVolume(false)
  5. {
  6.     //APS实现了AudioPolicyClientInterface接口
  7.     mpClientInterface= clientInterface;//这个clientInterface就是APS对象
  8.     //清空强制使用配置
  9.     for(int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) {
  10.        mForceUse[i] = AudioSystem::FORCE_NONE;
  11.     }
  12.     //输出设备有听筒和扬声器
  13.     mAvailableOutputDevices = AudioSystem::DEVICE_OUT_EARPIECE | AudioSystem::DEVICE_OUT_SPEAKER;
  14.     //输入设备是内置的麦克（学名叫传声器）
  15.     mAvailableInputDevices = AudioSystem::DEVICE_IN_BUILTIN_MIC;
  16. #ifdef WITH_A2DP //和蓝牙立体声有关。
  17.     mA2dpOutput = 0;
  18.     mDuplicatedOutput = 0;
  19.     mA2dpDeviceAddress = String8("");
  20. #endif
  21.     mScoDeviceAddress = String8(""); //SCO主要用于通话
  22.    /*
  23.     1 创建一个AudioOutputDescriptor对象，这个对象用来记录并维护与
  24.     输出设备（相当于硬件的音频DSP）相关的信息，例如使用该设备的流个数、各个流的音量、
  25.     该设备所支持的采样率、采样精度等。其中，有一个成员mDevice用来表示目前使用的输出设备，例如耳机、听筒、扬声器等
  26.    */
  27.     AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
  28.     outputDesc->mDevice= (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER;
  29.    /*
  30.     2 还记得MixerThread的来历吗？openOutput导致AF创建了一个工作线程。
  31.     该函数返回的是一个工作线程索引号
  32.    */
  33.     mHardwareOutput =mpClientInterface->openOutput(&outputDesc->mDevice,
  34.                                    &outputDesc->mSamplingRate,
  35.                                    &outputDesc->mFormat,
  36.                                    &outputDesc->mChannels,
  37.                                    &outputDesc->mLatency,
  38.                                    outputDesc->mFlags);
  39.     ......
  40.     //AMB维护了一个与设备相关的key/value集合，下面将对应信息加到该集合中。
  41.     addOutput(mHardwareOutput,outputDesc);
  42.     //3 设置输出设备，就是设置DSP的数据流到底从什么设备出去，这里设置的是从扬声器出去
  43.     setOutputDevice(mHardwareOutput, (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER,true);
  44.     }
  45.     //4 更新不同策略使用的设备
  46.     updateDeviceForStrategy();
  47. }

关于AMB这个小小的构造函数，有几个重要点需要介绍：
（1）AudioOutputDescriptor和openOutput
AudioOutputDescriptor对象，是AMB用来控制和管理音频输出设备的，从硬件上看，它代表的是DSP设备。关于这一点已在注释中做出说明，这里就不再赘述。另一个重要点是openOutput函数。该函数的实现由APS来完成。之前曾分析过，它最终会在AF中创建一个混音线程（不考虑DirectOutput的情况），该函数返回的是该线程在AF中的索引号，亦即mHardwareOutput表示的是AF中一个混音线程的索引号。
图14展示了AMB和AF及MixerThread之间的关系：

图14  AF、AMB及MixerThread之间的关系

图14表明：

·  AMB中除了mHardwareOutput外，还有一个mA2dpOutput，它对应的MixerThread，专往代表蓝牙A2DP设备的AudioStreamOut上发送数据。关于这个问题，在后面分析DuplicatingThread时可以见到。

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

·  除了蓝牙外，系统中一般也就只有图14右边这么一个MixerThread了，所以AMB通过mHardwareOutput就能控制整个系统的声音，这真是一劳永逸。

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

（2）setOutputDevice

现在要分析的调用是setOutputDevice，目的是为DSP选择一个合适的输出设备。注意它的第一个参数是传入的mHardwareOutput，它最终会找到代表DSP的AudioStreamOut对象，第二个参数是一个设备号。

[-->AudioPolicyManagerBase.cpp]

  1. void AudioPolicyManagerBase::setOutputDevice(audio_io_handle_toutput,
  2.                                    uint32_tdevice, bool force, int delayMs)
  3. {
  4.     AudioOutputDescriptor*outputDesc = mOutputs.valueFor(output);
  5.     //判断是否是Duplicate输出，和蓝牙A2DP有关，后面再做分析
  6.     if(outputDesc->isDuplicated()) {
  7.        setOutputDevice(outputDesc->mOutput1->mId, device, force,delayMs);
  8.        setOutputDevice(outputDesc->mOutput2->mId, device, force,delayMs);
  9.        return;
  10.     }
  11.     // 初始设置的输出设备为听筒和扬声器
  12.     uint32_tprevDevice = (uint32_t)outputDesc->device();
  13.     if ((device == 0 || device == prevDevice)&& !force) {
  14.        return;
  15.     }
  16.     //现在设置新的输出设备为扬声器，注意这是软件层面上的设置
  17.     outputDesc->mDevice = device;
  18.     ......
  19.     /*
  20.     还需要硬件也做相应设置，主要是告诉DSP把它的输出切换到某个设备上，根据之前的分析，
  21.     这个请求要发送到AF中的MixerThread上，因为只有它拥有代表输出设备的AudioStreamOut对象
  22.     */
  23.     AudioParameter param = AudioParameter();
  24.     param.addInt(String8(AudioParameter::keyRouting),(int)device);
  25.     /*
  26.     上面的配置参数将投递到APS的消息队列，而APS中创建的AudioCommandThread
  27.     会取出这个配置参数，再投递给AF中对应的MixerThread，最终由MixerThread处理。
  28.     这个流程，将在耳机插拔事件处理中进行分析
  29.     */
  30.     mpClientInterface->setParameters(mHardwareOutput, param.toString(), delayMs);
  31.     ......
  32. }

setOutputDevice要实现的目的已很明确，只是实现的过程比较繁琐而已。其间没有太多复杂之处，读者可自行研究，以加深对Audio系统的了解。
（3）Audio Strategy
现调用的函数是updateDeviceForStrategy，这里会引出一个strategy的概念。先看updataDeviceForStrategy函数：
[-->AudioPolicyManagerBase.cpp]

  1. void AudioPolicyManagerBase::updateDeviceForStrategy()
  2. {
  3.     for(int i = 0; i < NUM_STRATEGIES; i++) {
  4.        mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i,false);
  5.     }
  6. }

关于getDeviceForStrategy，在耳机插拔事件中再做分析，现在先看routing_stratgy的定义，代码如下所示：

[-->getDeviceForStrategy.h::routing_strategy]

  1. //routing_strategy:路由策略
  2. enum routing_strategy {
  3.            STRATEGY_MEDIA,
  4.            STRATEGY_PHONE,
  5.            STRATEGY_SONIFICATION,
  6.            STRATEGY_DTMF,
  7.            NUM_STRATEGIES
  8. }

它是在AudioPolicyManagerBase.h中定义的，一般的应用程序不会使用这个头文件。这个routing_strategy有什么用处呢？从名字上看，似乎和路由的选择有关系，但AudioSystem定义的是stream type，这两者之间会有什么关系吗？有，而且还很紧密。这个关系通过AMB的getStrategy就可以看出来。它会从指定的流类型得到对应的路由策略，代码如下所示：
[-->AudioPolicyManagerBase.cpp]

  1. AudioPolicyManagerBase::getStrategy(AudioSystem::stream_typestream)
  2. {
  3.     switch(stream) {
  4.     caseAudioSystem::VOICE_CALL:
  5.     caseAudioSystem::BLUETOOTH_SCO:
  6.         return STRATEGY_PHONE; //PHONE路由策略
  7.     caseAudioSystem::RING:
  8.     caseAudioSystem::NOTIFICATION:
  9.     caseAudioSystem::ALARM:
  10.     caseAudioSystem::ENFORCED_AUDIBLE:
  11.        return STRATEGY_SONIFICATION; //SONIFICATION路由策略
  12.     caseAudioSystem::DTMF:
  13.        return STRATEGY_DTMF;  //DTMF路由策略
  14.     default:
  15.        LOGE("unknown stream type");
  16.     caseAudioSystem::SYSTEM:
  17.     caseAudioSystem::TTS:
  18.     caseAudioSystem::MUSIC:
  19.        return STRATEGY_MEDIA;//media 路由策略
  20.     }
  21. }

从这个函数中可看出，AudioSystem使用的流类型并不是和路由直接相关的，AMB或AudioPolicy内部，是使用routing_strategy来控制路由策略的。

5. 小结

·  图13展示了智能手机的硬件架构，通过和Audio相关的架构设计，我们能理解Audio系统设计的缘由。
·  图14展示了APS和AF内部联系的纽带，后续APS的控制无非就是找到对应的MixerThread，给它发送控制消息，最终由MixerThread将控制信息传给对应的代表音频输出设备的HAL对象。

4.2 重回AudioTrack

按照前文所介绍的内容可知，AudioTrack在调用createTrack时，会传入一个audio_handle_t，这个值表示AF中某个工作线程的索引号，而它又是从APS中得到的。那么，这中间又有哪些曲折的经历呢？
先回顾一下AudioTrack的set函数。

1. 重回set

先来看相应的代码，如下所示：
[--->AudioTrack.cpp]

  1. status_t AudioTrack::set(int streamType,uint32_tsampleRate,int format,
  2.                           int channels,intframeCount,uint32_t flags,
  3.                           callback_t cbf,void*user,int notificationFrames,
  4.                           constsp<IMemory>& sharedBuffer, bool threadCanCallJava)
  5. {
  6.     ......
  7.     //得到AF中一个工作线程的索引号
  8.     audio_io_handle_toutput = AudioSystem::getOutput(
  9.                                    (AudioSystem::stream_type)streamType,
  10.                                    sampleRate,format, channels,
  11.                                    (AudioSystem::output_flags)flags);
  12.     ......
  13.     //创建Track，最终会调到AF的createTrack
  14.     status_t status = createTrack(streamType,sampleRate, format, channelCount,
  15.                                   frameCount,flags, sharedBuffer, output);
  16.     ......
  17. }

再看AudioSystem是如何实现getOutput的，代码如下所示：
[-->AudioSystem.cpp]

  1. audio_io_handle_tAudioSystem::getOutput(stream_type stream,
  2.                                     uint32_tsamplingRate,
  3.                                     uint32_tformat,
  4.                                     uint32_tchannels,
  5.                                     output_flagsflags)
  6. {
  7.     audio_io_handle_t output = 0;
  8.     ......
  9.     if(output == 0) {
  10.         const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
  11.         if(aps == 0) return 0;
  12.         //调用AP的getOutput函数
  13.         output = aps->getOutput(stream, samplingRate, format, channels, flags);
  14.         if((flags & AudioSystem::OUTPUT_FLAG_DIRECT) == 0) {
  15.            Mutex::Autolock _l(gLock);
  16.            //把这个stream和output的对应关系保存到map中
  17.            AudioSystem::gStreamOutputMap.add(stream, output);
  18.         }
  19.     }
  20.     return output;
  21. }

这里调用了AP的getOutput，来看：
[-->AudioPolicyService.cpp]

  1. audio_io_handle_t AudioPolicyService::getOutput(
  2.                           AudioSystem::stream_typestream, uint32_t samplingRate,
  3.                           uint32_tformat,uint32_t channels,
  4.                           AudioSystem::output_flagsflags)
  5. {
  6.     //和硬件厂商的实现相关，所以交给AudioPolicyInterface处理
  7.     //这里将由AudioPolicyManagerBase处理
  8.     Mutex::Autolock _l(mLock);
  9.     return mpPolicyManager->getOutput(stream, samplingRate, format, channels, flags);
  10. }

[->AudioPolicyManagerBase.cpp]

  1. audio_io_handle_t AudioPolicyManagerBase::getOutput(
  2.                      AudioSystem::stream_typestream, uint32_t samplingRate,
  3.                      uint32_t format,uint32_tchannels,
  4.                      AudioSystem::output_flagsflags)
  5. {
  6.     audio_io_handle_t output = 0;
  7.     uint32_tlatency = 0;
  8.     //根据流类型得到对应的路由策略，这个我们已经见过了，MUSIC类型返回MUSIC策略
  9.     routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
  10.     //根据策略得到使用这个策略的输出设备（指扬声器之类的），以后再看这个函数
  11.     uint32_t device = getDeviceForStrategy(strategy);
  12.     ......
  13.     //看这个设备是不是与蓝牙的A2DP相关
  14.     uint32_t a2dpDevice = device & AudioSystem::DEVICE_OUT_ALL_A2DP;
  15.     if(AudioSystem::popCount((AudioSystem::audio_devices)device) == 2) {
  16. #ifdef WITH_A2DP
  17.         //对于有A2DP支持，a2dpUsedForSonification函数直接返回true
  18.         if (a2dpUsedForSonification() &&a2dpDevice != 0) {
  19.             //和DuplicatingThread相关，以后再看
  20.             output = mDuplicatedOutput;
  21.         } else
  22. #endif
  23.         {
  24.             output = mHardwareOutput; //使用非蓝牙的混音输出线程
  25.         }
  26.     } else {
  27. #ifdef WITH_A2DP
  28.         if(a2dpDevice != 0) {
  29.             //使用蓝牙的混音输出线程
  30.             output = mA2dpOutput;
  31.         } else
  32. #endif
  33.         {
  34.           output = mHardwareOutput;
  35.         }
  36.     }
  37.     return output;
  38. }

终于明白了！原来，AudioSystem的getOutput就是想找到AF中的一个工作线程。为什么这个线程号会由AP返回呢？是因为Audio系统需要：
·  根据流类型找到对应的路由策略。
·  根据该策略找到合适的输出device（指扬声器、听筒之类的）。
·  根据device选择AF中合适的工作线程，例如是蓝牙的MixerThread，还是DSP的MixerThread，或者是DuplicatingThread。
·  AT根据得到的工作线程索引号，最终将在对应的工作线程中创建一个Track。之后，AT的数据将由该线程负责处理。
下面用图15来回顾一下上面AT、AF、AP之间的交互关系。

图15  Audio三巨头的交互关系
图15充分展示了AT、AF和AP之间复杂微妙的关系。关系虽复杂，但目的却单纯。读者在分析时一定要明确目的。下面从目的开始，反推该流程：
·  AT的目的是把数据发送给对应的设备，例如是蓝牙、DSP等。
·  代表输出设备的HAL对象由MixerThread线程持有，所以要找到对应的MixerThread。
·  AP维护流类型和输出设备（耳机、蓝牙耳机、听筒等）之间的关系，不同的输出设备使用不同的混音线程。
·  AT根据自己的流类型，向AudioSystem查询，希望得到对应的混音线程号。
这样，三者精妙配合，便达到了预期目的。

2. 重回start

现在要分析的是start函数。AT的start虽没有直接与AP交互，但在AF的start中却和AP有着交互关系。其代码如下所示：
[-->AudioFlinger.cpp]

  1. status_t AudioFlinger::PlaybackThread::Track::start()
  2. {
  3.     status_t status = NO_ERROR;
  4.     sp<ThreadBase> thread = mThread.promote();
  5.     ......
  6.     if(!isOutputTrack() && state != ACTIVE && state != RESUMING) {
  7.          thread->mLock.unlock();
  8.          //调用AudioSystem的startOutput
  9.          status = AudioSystem::startOutput(thread->id(), (AudioSystem::stream_type)mStreamType);
  10.          thread->mLock.lock();
  11.     }
  12.     PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
  13.     playbackThread->addTrack_l(this);//把这个Track加入到活跃Track数组中
  14.     return status;
  15. }

下面来看AudioSystem的startOutput，代码如下所示：
[-->AudioSystem.cpp]

  1. status_t AudioSystem::startOutput(audio_io_handle_t output,
  2.                                          AudioSystem::stream_typestream)
  3. {
  4.    constsp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
  5.    if (aps== 0) return PERMISSION_DENIED;
  6.    //调用AP的startOutput，最终由AMB完成实际功能
  7.    return aps->startOutput(output, stream);
  8. }

[-->AudioPolicyManagerBase.cpp]

  1. status_t AudioPolicyManagerBase::startOutput(audio_io_handle_t output,
  2.                                          AudioSystem::stream_typestream)
  3. {
  4.     //根据output找到对应的AudioOutputDescriptor
  5.     ssize_t index = mOutputs.indexOfKey(output);
  6.     AudioOutputDescriptor* outputDesc = mOutputs.valueAt(index);
  7.     //找到对应流使用的路由策略
  8.     routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
  9.     //增加outputDesc中该流的使用计数，1表示增加1
  10.     outputDesc->changeRefCount(stream, 1);
  11.     //getNewDevice将得到一个设备，setOutputDevice将使用这个设备进行路由切换。
  12.     //至于setOutputDevice，我们在分析耳机插入事件时再来讲解
  13.     setOutputDevice(output, getNewDevice(output));
  14.     //设置音量，读者可自行分析
  15.     checkAndSetVolume(stream,mStreams[stream].mIndexCur, output, outputDesc->device());
  16.     return NO_ERROR;
  17. }

再看getNewDevice，它和音频流的使用计数有关系：
[-->AudioPolicyManagerBase.cpp]

  1. uint32_t AudioPolicyManagerBase::getNewDevice(audio_io_handle_t output, bool fromCache)
  2. {
  3.     uint32_t device = 0;
  4.     AudioOutputDescriptor*outputDesc = mOutputs.valueFor(output);
  5.     /*
  6.     isUsedByStrategy判断某个策略是否正在被使用，之前曾通过changeRefCount为
  7.     MUSIC流使用计数增加了1，所以使用MUSIC策略的个数至少为1，这表明，此设备正在使用该策略。
  8.     一旦得到当前outputDesc使用的策略，便可根据该策略找到对应的设备。
  9.     注意if和else的顺序，它代表了系统优先使用的策略,以第一个判断为例，
  10.     假设系统已经插上耳机，并且处于通话状态时，而且强制使用了扬声器，那么声音都从扬声器出。
  11.     这时，如果想听音乐的话，则应首先使用STRATEGY_PHONE的对应设备，此时就是扬声器。
  12.     所以音乐将从扬声器出来，而不是耳机。上面仅是举例，具体的情况还要综合考虑Audio
  13.     系统中的其他信息。另外如果fromCache为true，将直接从内部保存的旧信息中得到设备，
  14.     关于这个问题，在后面的耳机插入事件处理中再做分析
  15.     */
  16.     if(mPhoneState == AudioSystem::MODE_IN_CALL ||
  17.        outputDesc->isUsedByStrategy(STRATEGY_PHONE)) {
  18.        device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);
  19.     } elseif (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION)) {
  20.        device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);
  21.     } elseif (outputDesc->isUsedByStrategy(STRATEGY_MEDIA)) {
  22.        device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);
  23.     } elseif (outputDesc->isUsedByStrategy(STRATEGY_DTMF)) {
  24.        device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);
  25.     }
  26.     return device;
  27. }

这里，有一个问题需要关注：
·  为什么startOutput函数会和设备切换有关系呢？
仅举一个例子，帮助理解这一问题。AudioTrack创建时可设置音频流类型，假设第一个AT创建时使用的是MUSIC类型，那么它将使用耳机出声（假设耳机已经连接上）。这时第二个AT创建了，它使用的是RING类型，它对应的策略应是SONIFACATION，这个策略的优先级比MUSIC要高（因为getNewDevice的判断语句首先会判断isUsedByStrategy(STRATEGY_SONIFICATION)），所以这时需要把设备切换为耳机加扬声器（假设这种类型的声音需要从耳机和扬声器同时输出）。startOutput的最终结果，是这两路的Track声音都将从耳机和扬声器中听到。当第二路AT调用stop时，对应音频流类型使用计数会减一，这会导致新的路由切换，并重新回到只有耳机的情况，这时第一路AT的声音会恢复为只从耳机输出。

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

3. 本节小结

这一节主要讲解了AudioTrack和AP之间的交互，总结为以下两点：
·  AT通过AP获取AF中的工作线程索引号，这决定了数据传输的最终目标是谁，比如是音频DSP或是蓝牙。
·  AT的start和stop会影响Audio系统的路由切换。
读完这一节，读者可能只会对与工作线程索引有关的内容印象较深刻，毕竟这个决定了数据传输的目的地。至于与路由切换有关的知识，可能就还不太了解了。下面，通过分析一个应用场景来启发、加深对它的理解。

4.3 声音路由切换实例分析

路由就是为DSP选择数据出口，例如是从耳机、听筒还是扬声器传出。下面分析这样一个场景：
·  假设我们在用扬声器听歌，这时把耳机插上，会发生什么呢？

1. 耳机插拔事件处理

耳机插上后，系统会发一个广播，Java层的AudioService会接收这个广播，其中的内部类AudioServiceBroadcastReceiver会处理该事件，处理函数是onReceive。这段代码在AudioSystem.java中。一起来看：
（1）耳机插拔事件接收
看这段代码，如下所示：
[-->AudioSystem.java::AudioServiceBroadcastReceiver的onReceive()]

  1. private class AudioServiceBroadcastReceiverextends BroadcastReceiver{
  2. @Override
  3.        public void onReceive(Context context, Intent intent) {
  4.            String action = intent.getAction();
  5.            ......
  6.            //如果该事件是耳机插拔事件
  7.            if (action.equals(Intent.ACTION_HEADSET_PLUG)) {
  8.                //取得耳机的状态
  9.                int state = intent.getIntExtra("state", 0);
  10.                int microphone = intent.getIntExtra("microphone", 0);
  11.                if (microphone != 0) {
  12.                     //查看已连接设备是不是已经有了耳机，耳机的设备号为0x4，
  13.                     //这个和AudioSystem.h定义的设备号是一致的
  14.                     boolean isConnected = mConnectedDevices.containsKey(
  15.                               AudioSystem.DEVICE_OUT_WIRED_HEADSET);
  16.                     //如果之前有耳机而现在没有，则认为是耳机拔出事件
  17.                     if (state == 0 && isConnected) {
  18.                         //设置Audio系统的设备连接状态，耳机为Unavailable
  19.                         AudioSystem.setDeviceConnectionState(
  20.                                 AudioSystem.DEVICE_OUT_WIRED_HEADSET,
  21.                                 AudioSystem.DEVICE_STATE_UNAVAILABLE,
  22.                                 "");
  23.                         //从已连接设备中去掉耳机设备
  24.                         mConnectedDevices.remove(AudioSystem.DEVICE_OUT_WIRED_HEADSET);
  25.                     } //如果state为1，并且之前没有耳机连接,则处理这个耳机插入事件
  26.                     else if (state == 1 && !isConnected){
  27.                         //设置Audio系统的设备连接状态，耳机为Available
  28.                         AudioSystem.setDeviceConnectionState(
  29.                             AudioSystem.DEVICE_OUT_WIRED_HEADSET,
  30.                             AudioSystem.DEVICE_STATE_AVAILABLE,
  31.                             "");
  32.                         //已连接设备中增加耳机  
  33.                         mConnectedDevices.put(
  34.                             new Integer(AudioSystem.DEVICE_OUT_WIRED_HEADSET),
  35.                             "");
  36.                     }
  37.                }
  38.            }
  39.        }
  40. }

从上面的代码中可看出，不论耳机插入还是拔出，都会调用AudioSystem的setDeviceConnectionState函数。
（2）setDeviceConnectionState：设置设备连接状态
这个函数被定义为Native函数。下面是它的定义：
[-->AudioSystem.java]

  1. public static native int setDeviceConnectionState(int device, int state,
  2.                                                              String device_address);
  3. //注意我们传入的参数，device为0X4表示耳机，state为1，device_address为""

该函数的Native实现，在android_media_AudioSystem.cpp中，对应函数是：
[->android_media_AudioSystem.cpp]

  1. static int android_media_AudioSystem_setDeviceConnectionState(
  2.                                       JNIEnv*env, jobject thiz, jint
  3.                                       device,jint state, jstring device_address)
  4. {
  5.     const char *c_address = env->GetStringUTFChars(device_address, NULL);
  6.     int status = check_AudioSystem_Command();
  7.     //调用Native AudioSystem的setDeviceConnectionState
  8.     AudioSystem::setDeviceConnectionState(
  9.                  static_cast<AudioSystem::audio_devices>(device),
  10.                  static_cast<AudioSystem::device_connection_state>(state),
  11.                  c_address));
  12.     env->ReleaseStringUTFChars(device_address, c_address);
  13.     return status;
  14. }

现在来看Native的对应函数：
[-->AudioSystem.cpp]

  1. status_t AudioSystem::setDeviceConnectionState(audio_devices device,
  2.                                                        device_connection_state state,
  3.                                                        const char *device_address)
  4. {
  5.     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
  6.     if(aps == 0) return PERMISSION_DENIED;
  7.     //转到AP去，最终由AMB处理
  8.     return aps->setDeviceConnectionState(device, state, device_address);
  9. }

Audio代码不厌其烦地把函数调用从这一类转移到另外一类，请直接看AMB的实现：
[-->AudioPolicyManagerBase.cpp]

  1. status_t AudioPolicyManagerBase::setDeviceConnectionState(
  2.                   AudioSystem::audio_devicesdevice,
  3.                   AudioSystem::device_connection_statestate,
  4.                   const char *device_address)
  5. {
  6.     //一次只能设置一个设备
  7.     if(AudioSystem::popCount(device) != 1) return BAD_VALUE;
  8.     ......
  9.     //根据设备号判断是不是输出设备，耳机肯定属于输出设备
  10.     if(AudioSystem::isOutputDevice(device)) {
  11.         switch (state)
  12.         {
  13.            case AudioSystem::DEVICE_STATE_AVAILABLE:
  14.                //处理耳机插入事件，mAvailableOutputDevices保存已连接的设备
  15.                //这个耳机是刚连上的，所以不走下面if分支
  16.                if (mAvailableOutputDevices & device) {
  17.                    //启用过了，就不再启用了。
  18.                    return INVALID_OPERATION;
  19.                }
  20.                //现在已连接设备中多了一个耳机
  21.                mAvailableOutputDevices |= device;
  22.                ....
  23.              
  24.                //1 getNewDevice之前已分析过了，这次再看
  25.                uint32_t newDevice =getNewDevice(mHardwareOutput, false);
  26.                //2 更新各种策略使用的设备
  27.                updateDeviceForStrategy();
  28.                //3 设置新的输出设备
  29.                setOutputDevice(mHardwareOutput,newDevice);
  30.                ......
  31.         }
  32. }

这里面有三个比较重要的函数，前面也已提过，现将其再进行一次较深入的分析，旨在加深读者对它的理解。
（3）getNewDevice
来看代码，如下所示：
[->AudioPolicyManagerBase.cpp]

  1. uint32_t AudioPolicyManagerBase::getNewDevice(audio_io_handle_t output,
  2.                                                        bool fromCache)
  3. {   //注意我们传入的参数，output为mHardwardOutput,fromCache为false
  4.     uint32_tdevice = 0;
  5.     //根据output找到对应的AudioOutputDescriptor，这个对象保存了一些信息
  6.     AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);
  7.     if(mPhoneState == AudioSystem::MODE_IN_CALL ||
  8.          outputDesc->isUsedByStrategy(STRATEGY_PHONE))
  9.     {
  10.         device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);
  11.     }
  12.     elseif (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION))
  13.     {
  14.         device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);
  15.     }
  16.     elseif (outputDesc->isUsedByStrategy(STRATEGY_MEDIA))
  17.     {
  18.         //应用场景是正在听歌，所以会走这个分支
  19.         device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);
  20.     }
  21.     elseif (outputDesc->isUsedByStrategy(STRATEGY_DTMF))
  22.     {
  23.         device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);
  24.     }
  25.     return device;
  26. }

策略是怎么和设备联系起来的呢？秘密就在getDeviceForStrategy中，来看：
[-->AudioPolicyManagerBase.cpp]

  1. uint32_t AudioPolicyManagerBase::getDeviceForStrategy(
  2.                                        routing_strategystrategy, bool fromCache)
  3. {
  4.     uint32_t device = 0;
  5.     if (fromCache){//如果为true，则直接取之前的旧值
  6.         return mDeviceForStrategy[strategy];
  7.     }
  8.     //如果fromCache为false，则需要重新计算策略所对应的设备
  9.     switch(strategy) {
  10.     case STRATEGY_DTMF://先处理DTMF策略的情况
  11.         if (mPhoneState != AudioSystem::MODE_IN_CALL) {
  12.            //如果不处于电话状态，则DTMF的策略和MEDIA策略对应同一个设备
  13.            device = getDeviceForStrategy(STRATEGY_MEDIA, false);
  14.            break;
  15.         }
  16.         //如果处于电话状态，则DTMF策略和PHONE策略用同一个设备
  17.     case STRATEGY_PHONE:
  18.         //是PHONE策略的时候，先要考虑是不是用户强制使用了某个设备，例如强制使用扬声器
  19.         switch (mForceUse[AudioSystem::FOR_COMMUNICATION]) {
  20.             ......
  21.             case AudioSystem::FORCE_SPEAKER:
  22.             ...... //如果没有蓝牙，则选择扬声器
  23.             device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER;
  24.             break;
  25.         }
  26.         break;
  27.     case STRATEGY_SONIFICATION://SONIFICATION策略
  28.         if (mPhoneState == AudioSystem::MODE_IN_CALL) {
  29.            /*
  30.              如果处于来电状态，则和PHONE策略用同一个设备。例如通话过程中我们强制使用
  31.              扬声器，那么这个时候按拨号键，则按键声也会从扬声器出来
  32.            */
  33.            device = getDeviceForStrategy(STRATEGY_PHONE, false);
  34.            break;
  35.         }
  36.         device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER;
  37.         //如果不处于电话状态，则SONIFICATION和MEDIA策略用同一个设备
  38.     case STRATEGY_MEDIA: {
  39.         //AUX_DIGITAL值为0x400，耳机不满足该条件
  40.         uint32_t device2 = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_AUX_DIGITAL;
  41.         if(device2 == 0) {
  42.            //也不满足WIRED_HEADPHONE条件
  43.            device2 = mAvailableOutputDevices &
  44.                                    AudioSystem::DEVICE_OUT_WIRED_HEADPHONE;
  45.         }
  46.         if(device2 == 0) {
  47.            //满足这个条件，所以device2为0x4，WIRED_HEADSET
  48.            device2 = mAvailableOutputDevices &
  49.                                       AudioSystem::DEVICE_OUT_WIRED_HEADSET;
  50.         }
  51.         if(device2 == 0) {
  52.            device2 = mAvailableOutputDevices &
  53.                                       AudioSystem::DEVICE_OUT_SPEAKER;
  54.         }
  55.         device |= device2; //最终device为0x4，WIRED_HEADSET
  56.     }break;
  57.     default:
  58.         break;
  59.     }
  60.     return device;
  61. }

getDeviceForStrategy是一个比较复杂的函数。它的复杂，在于选取设备时，需考虑很多情况。getNewDevice将返回耳机的设备号0x4。下一个函数是updateDeviceForStrategy。
（4）updateDeviceForStrategy
同样是来看相应的代码，如下所示：
[-->AudioPolicyManagerBase.cpp]

  1. void AudioPolicyManagerBase::updateDeviceForStrategy()
  2. {
  3.     for(int i = 0; i < NUM_STRATEGIES; i++) {
  4.         //重新计算每种策略使用的设备，并保存到mDeviceForStrategy中，起到了cache的作用
  5.         mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i,false);
  6.     }
  7. }

updateDeviceForStrategy会重新计算每种策略对应的设备。
另外，如果updateDeviceForStrategy和getNewDevice互换位置，就会节省很多不必要的调用。
现在看最后一个函数setOutputDevice。
（5）setOutputDevice
继续看setOutputDevice的代码，如下所示：
[-->AudioPolicyManagerBase.cpp]

  1. void AudioPolicyManagerBase::setOutputDevice(audio_io_handle_t output,
  2.                                                uint32_t device,bool force, int delayMs)
  3. {
  4.     ......
  5.     //把这个请求要发送到output对应的AF工作线程中
  6.     AudioParameterparam = AudioParameter();
  7.     //参数是key/vlaue键值对的格式
  8.     param.addInt(String8(AudioParameter::keyRouting),(int)device);
  9.     //mpClientInterface是AP对象，由它处理
  10.     mpClientInterface->setParameters(mHardwareOutput,
  11.                                             param.toString(),delayMs);
  12.    //设置音量，不做讨论，读者可自行分析
  13.    applyStreamVolumes(output, device, delayMs);
  14. }

setParameters最终会调用APS的setParameters，代码如下所示：
[-->AudioPolicyService.cpp]

  1. void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
  2.                               const String8& keyValuePairs, int delayMs)
  3. {
  4.     //把这个请求加入到AudioCommandThread处理
  5.     mAudioCommandThread->parametersCommand((int)ioHandle,
  6.                                                  keyValuePairs, delayMs);
  7. }

AudioPolicyService创建时会同时创建两个线程，其中一个用于处理各种请求。现在看看它是怎么做的。

2. AudioCommandThread

AudioCommandThread有一个请求处理队列，AP负责往该队列中提交请求，而AudioCommandThread在它的线程函数threadLoop中处理这些命令。请直接看命令是如何处理的。
说明：这种通过一个队列来协调两个线程的方法，在多线程编程中非常常见，它也属于生产者/消费者模型。
（1）AudioCommandThread中的处理
[-->AudioPolicyService.cpp]

  1. bool AudioPolicyService::AudioCommandThread::threadLoop()
  2. {
  3.     nsecs_t waitTime = INT64_MAX;
  4.     mLock.lock();
  5.     while(!exitPending())
  6.     {
  7.        while(!mAudioCommands.isEmpty()) {
  8.            nsecs_t curTime = systemTime();
  9.            if (mAudioCommands[0]->mTime <= curTime) {
  10.                AudioCommand *command = mAudioCommands[0];
  11.                mAudioCommands.removeAt(0);
  12.                mLastCommand = *command;
  13.                switch (command->mCommand) {
  14.                case START_TONE:
  15.                    ......
  16.                case STOP_TONE: {
  17.                    ......  //TONE处理
  18.                     mLock.lock();
  19.                     }break;
  20.                case SET_VOLUME: {
  21.                     //设置音量
  22.                     delete data;
  23.                     }break;
  24.                case SET_PARAMETERS: {
  25.                     //处理路由设置请求
  26.                     ParametersData *data =(ParametersData *)command->mParam;
  27.                     //转到AudioSystem处理，mIO的值为mHardwareOutput
  28.                     command->mStatus =AudioSystem::setParameters(
  29.                                           data->mIO,
  30.                                           data->mKeyValuePairs);
  31.                     if(command->mWaitStatus) {
  32.                         command->mCond.signal();
  33.                         mWaitWorkCV.wait(mLock);
  34.                     }
  35.                     delete data;
  36.                     }break;
  37.                ......
  38.                default:
  39.                }
  40.            }
  41.         }
  42.     }
  43. }

Audio系统真是非常绕！先看AudioSystem的setParameters。
（2）AudioSystem的setParameters
AudioSystem将设置请求转移给AudioFlinger处理，代码如下所示：
[-->AudioSystem.cpp]

  1. status_t AudioSystem::setParameters(audio_io_handle_t ioHandle,
  2.                                            constString8& keyValuePairs)
  3. {
  4.     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
  5.     //果然是交给AF处理，ioHandle看来一定就是工作线程索引号了
  6.     return af->setParameters(ioHandle, keyValuePairs);
  7. }

[-->AudioFlinger.cpp]

  1. status_t AudioFlinger::setParameters(int ioHandle,
  2.                                          const String8& keyValuePairs)
  3. {
  4.     status_t result;
  5.     // ioHandle == 0 表示和混音线程无关，需要直接设置到HAL对象中。
  6.     if(ioHandle == 0) {
  7.        AutoMutex lock(mHardwareLock);
  8.        mHardwareStatus = AUDIO_SET_PARAMETER;
  9.        //调用AudioHardwareInterface的参数设置接口
  10.        result = mAudioHardware->setParameters(keyValuePairs);
  11.        mHardwareStatus = AUDIO_HW_IDLE;
  12.        return result;
  13.     }
  14.     sp<ThreadBase> thread;
  15.     {
  16.        Mutex::Autolock _l(mLock);
  17.        //根据索引号找到对应混音线程。
  18.        thread = checkPlaybackThread_l(ioHandle);
  19.     }
  20.     //我们只有一个MixerThread,交给它处理，这又是一个命令处理队列
  21.     result = thread->setParameters(keyValuePairs);
  22.     return result;
  23. }

好了，最终的请求处理在MixerThread的线程函数中，来看：
（3）MixerThread最终处理
代码如下所示：
[-->AudioFlinger.cpp]

  1. bool AudioFlinger::MixerThread::threadLoop()
  2. {
  3.     ....
  4.     while(!exitPending())
  5.     {
  6.         processConfigEvents();
  7.         mixerStatus = MIXER_IDLE;
  8.         {  // scope for mLock
  9.            Mutex::Autolock _l(mLock);
  10.            // checkForNewParameters_l最有嫌疑
  11.            if (checkForNewParameters_l()) {
  12.               ...
  13.            }
  14.            ......//其他处理
  15.         }
  16.     }
  17. }
  18.  
  19. bool AudioFlinger::MixerThread::checkForNewParameters_l()
  20. {
  21.     boolreconfig = false;
  22.     while(!mNewParameters.isEmpty()) {
  23.        status_t status = NO_ERROR;
  24.        String8 keyValuePair = mNewParameters[0];
  25.        AudioParameter param = AudioParameter(keyValuePair);
  26.        int value;
  27.        ......
  28.     }
  29.     //路由设置需要硬件参与，所以直接交给代表音频输出设备的HAL对象处理
  30.     status = mOutput->setParameters(keyValuePair);
  31.     return reconfig;
  32. }

HAL的setParameters到底是怎么工作的呢？不妨再来看一个实际的HAL对象处理例子。
（4）真实设备的处理
这个实际的Hardware，位于hardware/msm7k/libaudio-qsd8k的Hardware.cpp中，它提供了一个实际的音频处理例子，这个Hardware针对的是高通公司的硬件。直接看它是怎么处理音频输出对象setParameters的，代码如下所示：
[-->AudioHardware.cpp AudioStreamOutMSM72xx::setParameters()]

  1. status_t AudioHardware::AudioStreamOutMSM72xx::setParameters(
  2.                                                     const String8& keyValuePairs)
  3. {
  4.     AudioParameter param = AudioParameter(keyValuePairs);
  5.     String8 key = String8(AudioParameter::keyRouting);
  6.     status_t status = NO_ERROR;
  7.     int device;
  8.     if(param.getInt(key, device) == NO_ERROR) {
  9.        mDevices = device;
  10.        //调用doRouting，mHardware就是AudioHardware对象
  11.        status = mHardware->doRouting();
  12.        param.remove(key);
  13.     }
  14.     ......
  15.     return status;
  16. }

[-->AudioHardware.cpp]

  1. status_t AudioHardware::doRouting()
  2. {
  3.     Mutex::Autolock lock(mLock);
  4.     uint32_t outputDevices = mOutput->devices();
  5.     status_t ret = NO_ERROR;
  6.     int sndDevice = -1;
  7.     ......
  8.     //做一些判断，最终由doAudioRouteOrMute处理
  9.     if((vr_mode_change) || (sndDevice != -1 && sndDevice != mCurSndDevice)) {
  10.         ret = doAudioRouteOrMute(sndDevice);
  11.         mCurSndDevice = sndDevice;
  12.     }
  13.     return ret;
  14. }
  15.  
  16. status_t AudioHardware::doAudioRouteOrMute(uint32_tdevice)
  17. {
  18.    uint32_t rx_acdb_id = 0;
  19.    uint32_t tx_acdb_id = 0;
  20.    //只看看就行，对应硬件相关的代码，咱们就是打打酱油
  21.    return do_route_audio_dev_ctrl(device,
  22.                mMode== AudioSystem::MODE_IN_CALL, rx_acdb_id, tx_acdb_id);
  23. }
  24.  
  25. static status_t do_route_audio_dev_ctrl(uint32_tdevice, bool inCall,
  26.                                             uint32_t rx_acdb_id, uint32_t tx_acdb_id)
  27. {
  28.    uint32_t out_device = 0, mic_device = 0;
  29.    uint32_t path[2];
  30.    int fd= 0;
  31.    //打开音频控制设备
  32.    fd =open("/dev/msm_audio_ctl", O_RDWR);
  33.    path[0]= out_device;
  34.    path[1]= rx_acdb_id;
  35.    //通过ioctl切换设备，一般系统调用都是返回-1表示出错，这里返回0表示出错
  36.    if(ioctl(fd, AUDIO_SWITCH_DEVICE, &path)) {
  37.       close(fd);
  38.       return -1;
  39.    }
  40.    ......
  41. }

4.4  AudioPolicy总结

要理解以下两点：
·  AP和AF的关系，关于这一部分的内容，读者应彻底弄懂图13。
·  关于设备连接导致的路由切换处理，读者要理解这期间的处理流程。

5  拓展思考

5.1 DuplicatingThread破解

DuplicatingThread需要与蓝牙结合起来使用，它的存在与Audio硬件结构息息相关。读者可参考图13“智能手机硬件架构图”来理解。当一份数据同时需要发送给DSP和蓝牙A2DP设备时，DuplicatingThread就派上用场了。在分析DuplicatingThread前，还是应该了解一下它的来龙去脉。

1. DuplicatingThread的来历

DuplicatingThread和蓝牙的A2DP设备有关系。可先假设有一个蓝牙立体声耳机已经连接上了，接着从setDeviceConnectionState开始分析，代码如下所示：
[-->AudioPolicyManagerBase.cpp]

  1. status_t AudioPolicyManagerBase::setDeviceConnectionState(
  2.                      AudioSystem::audio_devicesdevice,
  3.                      AudioSystem::device_connection_state state,
  4.                      const char *device_address)
  5. {
  6.         ......
  7.         switch (state)
  8.         {
  9.           case AudioSystem::DEVICE_STATE_AVAILABLE:
  10.            mAvailableOutputDevices |= device;
  11. #ifdef WITH_A2DP
  12.            if (AudioSystem::isA2dpDevice(device)) {
  13.                //专门处理A2DP设备的连接
  14.                status_t status = handleA2dpConnection(device, device_address);
  15.            }
  16. #endif
  17.         ......
  18.         }
  19. }

对于A2DP设备，有专门的函数handleA2dpConnection处理，代码如下所示：
[-->AudioPolicyManagerBase.cpp]

  1. status_t AudioPolicyManagerBase::handleA2dpConnection(
  2.                                         AudioSystem::audio_devicesdevice,
  3.                                         const char*device_address)
  4. {
  5.     AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
  6.     outputDesc->mDevice= device;
  7.     //先为mA2dpOutput创建一个MixerThread，这个和mHardwareOutput一样
  8.     mA2dpOutput =mpClientInterface->openOutput(&outputDesc->mDevice,
  9.                                            &outputDesc->mSamplingRate,
  10.                                            &outputDesc->mFormat,
  11.                                            &outputDesc->mChannels,
  12.                                            &outputDesc->mLatency,
  13.                                            outputDesc->mFlags);
  14.     if (mA2dpOutput) {
  15.         /*
  16.            a2dpUsedForSonification永远返回true，表示属于SONIFCATION策略的音频流声音需要
  17.            同时从蓝牙和DSP中传出。属于SONIFCATION策略的音频流类型可查看前面关于getStrategy的
  18.            分析，来电铃声、短信通知等属于这一类
  19.         */
  20.         if(a2dpUsedForSonification()) {
  21.            /*
  22.            创建一个DuplicateOutput，注意它的参数，第一个是蓝牙MixerThread
  23.            第二个是DSPMixerThread
  24.            */
  25.            mDuplicatedOutput = mpClientInterface->openDuplicateOutput(mA2dpOutput, mHardwareOutput);
  26.         }
  27.         if(mDuplicatedOutput != 0 ||
  28.            !a2dpUsedForSonification()) {
  29.            if (a2dpUsedForSonification()) {
  30.                 //创建一个AudioOutputDescriptor对象
  31.                 AudioOutputDescriptor *dupOutputDesc = new AudioOutputDescriptor();
  32.                 dupOutputDesc->mOutput1 = mOutputs.valueFor(mHardwareOutput);
  33.                 dupOutputDesc->mOutput2 = mOutputs.valueFor(mA2dpOutput);
  34.                 ......
  35.                 //保存mDuplicatedOutput和dupOutputDesc键值对
  36.                 addOutput(mDuplicatedOutput, dupOutputDesc);
  37.                 ......
  38.            }
  39.         }
  40.     }
  41.     ......
  42. }

这里，最重要的函数是openDuplicateOutput。它和openOutput一样，最终的处理都是在AF中。去那里看看，代码如下所示：
[-->AudioFlinger.cpp]

  1. int AudioFlinger::openDuplicateOutput(intoutput1, int output2)
  2. {
  3.     Mutex::Autolock_l(mLock);
  4.     //output1对应蓝牙的MixerThread
  5.     MixerThread*thread1 = checkMixerThread_l(output1);
  6.     //output2对应DSP的MixerThread
  7.     MixerThread *thread2 = checkMixerThread_l(output2);
  8.     //1 创建DuplicatingThread，注意它第二个参数使用的，是代表蓝牙的MixerThread
  9.     DuplicatingThread *thread = new DuplicatingThread(this, thread1, ++mNextThreadId);
  10.     //2 加入代表DSP的MixerThread
  11.     thread->addOutputTrack(thread2);
  12.     mPlaybackThreads.add(mNextThreadId, thread);
  13.     return mNextThreadId;    //返回DuplicatingThread的索引
  14. }

从现在起，MixerThread要简写为MT，而DuplicatingThread则简写为DT。
OK，这里面有两个重要的函数调用，一起来看。

2. DuplicatingThread和addOutputTrack

先看DT的构造函数，代码如下所示：
[-->AudioFlinger.cpp]

  1. AudioFlinger::DuplicatingThread::DuplicatingThread(constsp<AudioFlinger>&
  2.                 audioFlinger, AudioFlinger::MixerThread*mainThread,int id)
  3.                 :   MixerThread(audioFlinger,mainThread->getOutput(), id),
  4.                     mWaitTimeMs(UINT_MAX)
  5. {
  6.     //DT是MT的派生类，所以先要完成基类的构造，还记得MT的构造吗？它会创建一个AudioMixer对象
  7.     mType =PlaybackThread::DUPLICATING;
  8.     //把代表蓝牙的MT加入进来，咱们看看
  9.     addOutputTrack(mainThread);
  10. }
  11.  
  12. void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
  13. {
  14.     int frameCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate();
  15.     //构造一个OutputTrack，它的第一个参数是MT
  16.     OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread,
  17.                                            this, mSampleRate, mFormat,
  18.                                            mChannelCount,frameCount);
  19.     if(outputTrack->cblk() != NULL) {
  20.         thread->setStreamVolume(AudioSystem::NUM_STREAM_TYPES, 1.0f);
  21.         //把这个outputTrack加入到mOutputTracks数组保存
  22.         mOutputTracks.add(outputTrack);
  23.         updateWaitTime();
  24.     }
  25. }

此时，当下面两句代码执行完：

  1. DuplicatingThread *thread = newDuplicatingThread(this, thread1,++mNextThreadId);
  2. thread->addOutputTrack(thread2);

DT分别构造了两个OutputTrack，一个对应蓝牙的MT，一个对应DSP的MT。现在来看OutputTrack为何方神圣，代码如下所示：
[-->AudioFlinger.cpp]

  1. AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
  2.         const wp<ThreadBase>& thread, DuplicatingThread*sourceThread,
  3.         uint32_t sampleRate, int format,int channelCount,int frameCount)
  4.         :Track(thread,NULL, AudioSystem::NUM_STREAM_TYPES, sampleRate,
  5.               format, channelCount, frameCount, NULL),//最后这个参数为NULL
  6.          mActive(false),mSourceThread(sourceThread)
  7. {
  8.      /*
  9.        OutputTrack从Track派生，所以需要先调用基类的构造，还记得Track构造函数
  10.        中的事情吗？它会创建一块内存，至于是不是共享内存，由Track构造函数的最后一个参数决定。
  11.        如果该值为NULL，表示没有客户端参与，则会在本进程内创建一块内存，这块内存的结构如
  12.        图4所示，前边为CB对象，后边为数据缓冲
  13.      */
  14.      //下面的这个thread对象为MT
  15.      PlaybackThread *playbackThread = (PlaybackThread *)thread.unsafe_get();
  16.      if(mCblk != NULL) {
  17.        mCblk->out = 1;//表示DT将往MT中写数据
  18.        //和前面所分析的AT、AF中的处理何其相似！
  19.        mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);
  20.        mCblk->volume[0] = mCblk->volume[1] = 0x1000;
  21.        mOutBuffer.frameCount = 0;
  22.        //把这个Track加到MT的Track中
  23.        playbackThread->mTracks.add(this);
  24.      }
  25. }

图16表示的是openDuplicateOutput的结果：

图16  openDuplicateOutput的结果示意图
图16说明（以蓝牙MT为例）：
·  蓝牙MT的Track中有一个成员为OutputTrack0。
·  DT的mOutputTracks也有一个成员指向OutputTrack0。这就好像DT是MT的客户端一样，它和前面分析的AT是AF的客户端类似。
·  红色部分代表数据传递用的缓冲。

3. DT的客户端AT

DT是从MT中派生的，根据AP和AT的交互流程，当AT创建的流类型对应策略为SONIFACATION时，它会从AP中得到代表DT的线程索引号。由于DT没有重载createTrack_l，所以这个过程也会创建一个Track对象（和MT创建Track对象一样）。此时的结果，将导致图16变成图17。

图17  有AT的DT全景图
图17把DT的工作方式表达得非常清晰了。一个DT配合两个OutputTrack中的进程内缓冲，把来自AT的数据原封不动地发给蓝牙MT和DSP MT，这简直就是个数据中继器！。不过俗话说得好，道理虽简单，实现却复杂。来看DT是如何完成这一复杂而艰巨的任务的吧。

4. DT的线程函数

DT的线程函数代码如下所示：
[-->AudioFlinger.cpp]

  1. bool AudioFlinger::DuplicatingThread::threadLoop()
  2. {
  3.     int16_t* curBuf = mMixBuffer;
  4.     Vector< sp<Track> > tracksToRemove;
  5.     uint32_t mixerStatus = MIXER_IDLE;
  6.     nsecs_t standbyTime = systemTime();
  7.     size_t mixBufferSize = mFrameCount*mFrameSize;
  8.     SortedVector< sp<OutputTrack> > outputTracks;
  9.     while(!exitPending())
  10.     {
  11.        processConfigEvents();
  12.        mixerStatus = MIXER_IDLE;
  13.        {
  14.           ......
  15.           //处理配置请求，和MT处理一样
  16.           const SortedVector< wp<Track> >& activeTracks =mActiveTracks;
  17.           for (size_t i = 0; i < mOutputTracks.size(); i++) {
  18.               outputTracks.add(mOutputTracks[i]);
  19.           }
  20.           //如果AT的Track停止了，则需要停止和MT共享的OutputTrack
  21.           if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) || mSuspended) {
  22.                if (!mStandby) {
  23.                     for (size_t i = 0; i <outputTracks.size(); i++) {
  24.                        outputTracks[i]->stop();
  25.                     }
  26.                     mStandby = true;
  27.                     mBytesWritten = 0;
  28.                }
  29.                ......
  30.                //DT从MT派生，天然具有混音的功能，所以这部分功能和MT一致
  31.                mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);
  32.           }
  33.           if(LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
  34.                //outputsReady将检查OutputTracks对应的MT状态
  35.                if (outputsReady(outputTracks)) {
  36.                    mAudioMixer->process(curBuf);//使用AudioMixer对象混音
  37.                } else {
  38.                    memset(curBuf, 0, mixBufferSize);
  39.                }
  40.                sleepTime = 0;
  41.                writeFrames = mFrameCount;
  42.           }
  43.           ......
  44.           if (sleepTime == 0) {
  45.               standbyTime = systemTime() +kStandbyTimeInNsecs;
  46.               for (size_t i = 0; i < outputTracks.size(); i++) {
  47.                    //将混音后的数据写到outputTrack中
  48.                    outputTracks[i]->write(curBuf, writeFrames);
  49.               }
  50.               mStandby = false;
  51.               mBytesWritten += mixBufferSize;
  52.           } else {
  53.               usleep(sleepTime);
  54.           }
  55.           tracksToRemove.clear();
  56.           outputTracks.clear();
  57.     }
  58.     return false;
  59. }

现在，来自远端进程AT的数据已得到了混音，这一份混音后的数据还将通过调用OutputTrack的write完成DT到其他两个MT的传输。注意，这里除了AT使用的Track外，还有DT和两个MT共享的OutputTrack。AT调用的start，将导致DT的Track加入到活跃数组中，但另外两个OutputTrack还没调用start。这些操作又是在哪里做的呢？来看write函数：
[-->AudioFlinger.cpp]

  1. bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames)
  2. {
  3.     //注意，此处的OutputTrack是DT和MT共享的
  4.     Buffer *pInBuffer;
  5.     BufferinBuffer;
  6.     uint32_t channels = mCblk->channels;
  7.     bool outputBufferFull = false;
  8.     inBuffer.frameCount = frames;
  9.     inBuffer.i16 = data;
  10.     uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
  11.     if(!mActive && frames != 0) {
  12.        //如果此Track没有活跃，则调用start激活
  13.        start();
  14.        ......
  15.     }
  16.     /*
  17.        现在，AF中的数据传递有三个线程：一个DT，两个MT。MT作为DT的二级消费者，
  18.        可能由于某种原因来不及消费数据，所以DT中提供了一个缓冲队列mBufferQueue，
  19.        把MT来不及消费的数据保存在这个缓冲队列中。注意这个缓冲队列容纳的临时缓冲
  20.        个数是有限制的，其限制值由kMaxOverFlowBuffers控制，初始化为10个
  21.     */
  22.     while(waitTimeLeftMs) {
  23.         //先消耗保存在缓冲队列的数据
  24.         if(mBufferQueue.size()) {
  25.            pInBuffer = mBufferQueue.itemAt(0);
  26.         }else {
  27.            pInBuffer = &inBuffer;
  28.         }
  29.         ......
  30.         //获取可写缓冲，下面这句代码是否和AT中对应的代码很相似？
  31.         if(obtainBuffer(&mOutBuffer, waitTimeLeftMs) ==
  32.                               (status_t)AudioTrack::NO_MORE_BUFFERS){
  33.                ......
  34.                break;
  35.         }
  36.         uint32_toutFrames = pInBuffer->frameCount > mOutBuffer.frameCount ?
  37.                                      mOutBuffer.frameCount: pInBuffer->frameCount;
  38.         //将数据拷贝到DT和MT共享的那块缓冲中去
  39.         memcpy(mOutBuffer.raw, pInBuffer->raw,
  40.                 outFrames * channels * sizeof(int16_t));
  41.         //更新写位置
  42.         mCblk->stepUser(outFrames);
  43.         pInBuffer->frameCount-= outFrames;
  44.         pInBuffer->i16 += outFrames * channels;
  45.         mOutBuffer.frameCount -= outFrames;
  46.         mOutBuffer.i16 += outFrames * channels;
  47.         ......
  48.      }//while 结束
  49.      if(inBuffer.frameCount) {
  50.      sp<ThreadBase> thread = mThread.promote();
  51.      if(thread != 0 && !thread->standby()) {
  52.         if (mBufferQueue.size() < kMaxOverFlowBuffers) {
  53.             pInBuffer = new Buffer;
  54.             pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channels];
  55.             pInBuffer->frameCount = inBuffer.frameCount;
  56.             pInBuffer->i16 = pInBuffer->mBuffer;
  57.             //拷贝旧数据到新的临时缓冲
  58.             memcpy(pInBuffer->raw, inBuffer.raw,
  59.                         inBuffer.frameCount *channels * sizeof(int16_t));
  60.             //保存这个临时缓冲
  61.             mBufferQueue.add(pInBuffer);
  62.         }
  63.      }
  64.      //如果数据全部写完
  65.      if(pInBuffer->frameCount == 0) {
  66.          if (mBufferQueue.size()) {
  67.             mBufferQueue.removeAt(0);
  68.             delete [] pInBuffer->mBuffer;
  69.             delete pInBuffer;//释放缓冲队列对应的数据缓冲
  70.      } else {
  71.             break;
  72.         }
  73.      }
  74.      ......
  75.      return outputBufferFull;
  76. }

数据就这样从AT通过DT的帮助，传输到蓝牙的MT和DSP的MT中了。这种方式继数据传输比直接使用MT传输要缓慢。
到这里，对DT的讲解就告一段落了。本人觉得，DT的实现是AF代码中最美妙的地方，多学习这些优秀代码，有助于提高学习者的水平。

6  本章小结

Audio是本书碰到的第一个复杂系统，这个系统整体示意图如图18所示：

图18  Audio系统大家族
从图18中可以看出：
·  音频数据的输入输出不论是Java层和Native层，都是通过AudioTrack和AudioRecord类完成的。事实上，Audio系统提供的I/O接口就是AudioTrack和AudioRecord类。音频I/O是Audio系统最重要的部分。建议读者反复阅读，加深理解。
·  AudioManager用来做音量调节、audio模式的选择、设备连接控制等。这些都会和Native的AP交互。从我个人博客和其他技术论坛的统计来看，较少有人关注AudioPolicy，毕竟在这一块Android已提供了一个足够好用的AudioPolicyManagerBase类。不过作为Audio系统不可或缺的一部分，AudioPolicy的重要性是不言而喻的。
建议：无论怎么说，数据I/O毕竟是Audio系统中关键之关键，所以请读者一定要仔细阅读，体会其中精妙所在。
Audio系统中还有其他部分（例如AudioRecord、Java层的AudioSystem，AudioService等），本书没有涉及。读者可结合个人需要自行分析。在现有的基础上，要学习，掌握这些内容都不会太难。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/499810
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号