- 背景介绍
AudioTrack与AudioFlinger之间的数据传输分为两种方式，MODE_STATIC与MODE_STREAM。
- MODE_STATIC：static方式适用于数据较小，实时性比较高的情形，比如ring，系统铃声等。这种模式下，是在AT端创建共享内存，一次性将数据copy到buffer中，然后传递到AF端。
- MODE_STREAM：stream方式适用于数据较大，media播放等更多其他的情况，也比较复杂。在这种模式下，共享内存是由AF创建的，然后通过生产者-消费者的模式，进行数据的传输。即AT是数据的生产者，AF是数据的消费者。这个数据读写的控制，是由struct audio_track_cblk_t来实现的，这篇文章主要来分析这个控制块的实现。
- audio_track_cblk_t的创建
- AT与AF之间，是通过IAudioTrack接口进行交互的，而这个audio_track_cblk_t的创建，就是在AT调用AF创建IAudioTrack接口的同时创建的。
- AT->AF.createTrack()//在AT.play之前，必须要与AF建立联系
- PlaybackThread.createTrack_l() //创建AT与AF之间实际功能调用的实现者
- new Track() //创建Track，并把它包装在实现了IAudioTrack接口的TrackHandle中
- TrackBase::TrackBase()//Track的父类，创建audio_track_cblk_t的工作是在TrackBase的构造函数中进行的
size_t size = sizeof(audio_track_cblk_t); //计算audio_track_cblk_t的大小 uint8_t channelCount = popcount(channelMask); size_t bufferSize = frameCount*channelCount*sizeof(int16_t); //计算实际数据buffer大小 if (sharedBuffer == 0) { size += bufferSize; //共享内存实际分配大小为：cblk + data buffer } if (client != NULL) { mCblkMemory = client->heap()->allocate(size); //分配共享内存，实际的实现会在其他文章中分析，这里之分析对共享内存的使用 if (mCblkMemory != 0) { mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer()); // audio_track_cblk_t* mCblk，指向共享内存的地址 if (mCblk != NULL) { // construct the shared structure in-place. new(mCblk) audio_track_cblk_t(); //这里是C++的语法：
//（1）struct可以像class一样，使用new来创建。
//（2）new创建的对象并没有在heap上，而是特定在mCblk指向的内存上创建，这样这块共享
// 内存的结构就变成了： |<- audio_track_cblk_t ->| ...data buffer... | // clear all buffers mCblk->frameCount = frameCount; //初始化cblk中的一些属性 mCblk->sampleRate = sampleRate; mChannelCount = channelCount; mChannelMask = channelMask; if (sharedBuffer == 0) { //sharedBuffer==0表示MODE_STREAM mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); //data buffer的地址，需要将audio_track_cblk_t的大小跳过 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t)); //clear buffer // Force underrun condition to avoid false underrun callback until first data is // written to buffer (other flags are cleared) mCblk->flags = CBLK_UNDERRUN_ON; } else { //否则就是MODE_STATIC，数据buffer直接使用由AT传递过来的已经申请好的共享内存 mBuffer = sharedBuffer->pointer(); } mBufferEnd = (uint8_t *)mBuffer + bufferSize; } } else { ALOGE("not enough memory for AudioTrack size=%u", size); client->heap()->dump("AudioTrack"); return; } } else { ……………… }
- audio_track_cblk_t的声明
struct audio_track_cblk_t { ...省略... // next 4 are offsets within "buffers" volatile uint32_t user; //user代表AT，生产者已经写了多少个frame volatile uint32_t server; //server代表AF，消费者已经读取了多少个frame uint32_t userBase; //与user结合使用，使之成为一个环形FIFO uint32_t serverBase; //同userBase // if there is a shared buffer, "buffers" is the value of pointer() for the shared // buffer, otherwise "buffers" points immediately after the control block void* buffers; //实际数据buffer的起始地址
//如果是MODE_STREAM，buffers紧跟在cblk后面
//如果是MODE_STATIC，buffers指向sharedBuffer
uint32_t frameCount; //数据buffer的大小，以Frame为单位 //以下3个loopXXX是与循环播放有关 uint32_t loopStart; uint32_t loopEnd; // read-only for server, read/write for client int loopCount; // read/write for client private: uint32_t mVolumeLR; //音量相关 public: uint32_t sampleRate; //采样率 // NOTE: audio_track_cblk_t::frameSize is not equal to AudioTrack::frameSize() for // 8 bit PCM data: in this case, mCblk->frameSize is based on a sample size of // 16 bit because data is converted to 16 bit before being stored in buffer uint8_t frameSize; //一单位frame的大小 ...省略... public: volatile int32_t flags;// Since the control block is always located in shared memory, this constructor // is only used for placement new(). It is never used for regular new() or stack. audio_track_cblk_t(); //cblk总是new在指定的共享内存上，而不是堆栈上 uint32_t stepUser(uint32_t frameCount); //AT更新写位置 bool stepServer(uint32_t frameCount); //AF更新读位置 void* buffer(uint32_t offset) const; //返回可写的地址 uint32_t framesAvailable(); //还有多少空间可写 uint32_t framesAvailable_l(); uint32_t framesReady(); //是否有可读数据 bool tryLock(); ...省略... };
- AT写数据流程
- framesAvailable()判断是否有可用空间
uint32_t audio_track_cblk_t::framesAvailable_l() { uint32_t u = user; uint32_t s = server; if (flags & CBLK_DIRECTION_MSK) { //以前的out标志，放在了flag中？表示AT？
//计算读的起始位置，取读位置与循环起始位置两者中较小的 uint32_t limit = (s < loopStart) ? s : loopStart;
//可读 = user - limit
//可写 = frameCount - 可读
//可写 = frameCount - (u - limit)
//可写 = frameCount + limit - u return limit + frameCount - u; } else { ....... } } - buffer()得到写空间起始地址
void* audio_track_cblk_t::buffer(uint32_t offset) const {
//这里传入的offset就是cblk->user，为了在有限长度的buffer内，模拟环形FIFO队列，就有了个userBase。
//当数据写满整个buffer的大小以后，会继续增加user的值，那么user*frameSize的大小就会超过cblk->buffers+(frameCount*frameSize)
//这时就需要userBase来进行调整，user每增加frameCount整个buffer的帧数，userBase会增加同样的大小，
//来保证user-userBase始终小于frameCount，这样cblk->buffers + (user - userBase)*frameSize就可以得到当前的写位置，
//这个写位置永远不会超过实际cblk->buffer + frameCount*frameSize。
//环形FIFO的精髓就在这 return (int8_t *)buffers + (offset - userBase) * frameSize; } - stepUser()更新写位置
/*获取了写位置，并写入数据后，需要更新user的位置*/
uint32_t audio_track_cblk_t::stepUser(uint32_t frameCount) { uint32_t u = user; u += frameCount; //frameCount表示这次写了多少个frame， ...省略... uint32_t fc = this->frameCount; //整个buffer有多少个frame if (u >= fc) { //如果已写的frame超过整个buffer // common case, user didn't just wrap if (u - fc >= userBase ) { //userBase + frameCount小于user，就需要使userBase同样调整 userBase += fc; } } else if (u >= userBase + fc) { //同上 // user just wrapped userBase += fc; } user = u; //更新user ...省略... return u; }
- AF读数据流程
- frameReady()看是否有数据可以读
uint32_t audio_track_cblk_t::framesReady() { uint32_t u = user; uint32_t s = server; if (flags & CBLK_DIRECTION_MSK) { if (u < loopEnd) { //如果还未写到循环结束 return u - s; } else { // do not block on mutex shared with client on AudioFlinger side if (!tryLock()) { ALOGW("framesReady() could not lock cblk"); return 0; } uint32_t frames = UINT_MAX; if (loopCount >= 0) { frames = (loopEnd - loopStart)*loopCount + u - s; } lock.unlock(); return frames; } } else { return s - u; } }
- stepServe()更新serve
bool audio_track_cblk_t::stepServer(uint32_t frameCount) { uint32_t s = server; bool flushed = (s == user); s += frameCount; if (flags & CBLK_DIRECTION_MSK) { // Mark that we have read the first buffer so that next time stepUser() is called // we switch to normal obtainBuffer() timeout period if (bufferTimeoutMs == MAX_STARTUP_TIMEOUT_MS) { bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS - 1; } // It is possible that we receive a flush() // while the mixer is processing a block: in this case, // stepServer() is called After the flush() has reset u & s and // we have s > u if (flushed) { ALOGW("stepServer occurred after track reset"); s = user; } } if (s >= loopEnd) { ALOGW_IF(s > loopEnd, "stepServer: s %u > loopEnd %u", s, loopEnd); s = loopStart; if (--loopCount == 0) { loopEnd = UINT_MAX; loopStart = UINT_MAX; } } //与user类似，调整serveBase实现环形FIFO uint32_t fc = this->frameCount; if (s >= fc) { // common case, server didn't just wrap if (s - fc >= serverBase ) { serverBase += fc; } } else if (s >= serverBase + fc) { // server just wrapped serverBase += fc; } server = s; if (!(flags & CBLK_INVALID_MSK)) { cv.signal(); } lock.unlock(); return true; }