Track

  64 AudioFlinger::ThreadBase::TrackBase::TrackBase(                                 
  65             ThreadBase *thread,                                                 
  66             const sp<Client>& client,                                           
  67             uint32_t sampleRate,                                                
  68             audio_format_t format,                                              
  69             audio_channel_mask_t channelMask,                                   
  70             size_t frameCount,                                                  
  71             void *buffer,                                                       
  72             int sessionId,                                                      
  73             int clientUid,                                                      
  74             IAudioFlinger::track_flags_t flags,                                 
  75             bool isOut,                                                         
  76             alloc_type alloc,                                                   
  77             track_type type)                                                    
  78     :   RefBase(), 
 115     size_t size = sizeof(audio_track_cblk_t);                                   
 116     size_t bufferSize = (buffer == NULL ? roundup(frameCount) : frameCount) * mFrameSize;
 117     if (buffer == NULL && alloc == ALLOC_CBLK) {                                
 118         size += bufferSize;                                                     
 119     }   
  121     if (client != 0) {                                                          
 122         mCblkMemory = client->heap()->allocate(size);                           
 123         if (mCblkMemory == 0 ||                                                 
 124                 (mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer())) == NULL) {
 125             ALOGE("not enough memory for AudioTrack size=%u", size);            
 126             client->heap()->dump("AudioTrack");                                 
 127             mCblkMemory.clear();                                                
 128             return;                                                                                                                     
 129         }  
 ...
 164         case ALLOC_CBLK:                                                        
 165             // clear all buffers                                                
 166             if (buffer == NULL) {                                               
 167                 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);            
 168                 memset(mBuffer, 0, bufferSize);                                 
 169             } else {                                                            
 170                 mBuffer = buffer;                                               
 171 #if 0                                                                           
 172                 mCblk->mFlags = CBLK_FORCEREADY;    // FIXME hack, need to fix the track ready logic
 173 #endif                                                                          
 174             }                                                                   
 175             break;                                                              
 176         case ALLOC_LOCAL:                                                       
 177             mBuffer = calloc(1, bufferSize);                                    
 178             break;                                                              
 179         case ALLOC_NONE:                                                        
 180             mBuffer = buffer;                                                                                                           
 181             break;  

说明：
117行，如果应用层传入NULL，则size会多bufferSize。
126行，会分配size大小内存
164和177，如果内存是track分配的话，则mBuffer跳过控制头指向分配的内存；如果是应用程序，则mBuffer指向应用层的buffer。

 373 AudioFlinger::PlaybackThread::Track::Track(                                                                                             
 374             PlaybackThread *thread,                                             
 375             const sp<Client>& client,                                           
 376             audio_stream_type_t streamType,                                     
 377             uint32_t sampleRate,                                                
 378             audio_format_t format,                                              
 379             audio_channel_mask_t channelMask,                                   
 380             size_t frameCount,                                                  
 381             void *buffer,                                                       
 382             const sp<IMemory>& sharedBuffer,                                    
 383             int sessionId,                                                      
 384             int uid,                                                            
 385             IAudioFlinger::track_flags_t flags,                                 
 386             track_type type) 
 ......
 421     if (sharedBuffer == 0) {                                                    
 422         mAudioTrackServerProxy = new AudioTrackServerProxy(mCblk, mBuffer, frameCount,
 423                 mFrameSize, !isExternalTrack(), sampleRate);                    
 424     } else {                                                                    
 425         mAudioTrackServerProxy = new StaticAudioTrackServerProxy(mCblk, mBuffer, frameCount,
 426                 mFrameSize);                                                    
 427     }                                                                           
 428     mServerProxy = mAudioTrackServerProxy;  
 ...
 }