AudioTrack
AudioTrack: It allows streaming of PCM audio buffers to the audio sink for playback
An AudioTrack instance can operate under two modes: static or streaming.
Location:
Android应用框架层
android/frameworks/base/media/java/android/media/AudioTrack.java
//对外提供的接口，还有包括AudioManager、AudioRecorder等对外的接口
本地框架层
android/frameworks/av/media/libaudioclient/AudioTrack.cpp
1. MODE_STATIC 和 MODE_STREAM
android/frameworks/base/media/java/android/media/AudioTrack.java
// keep these values in sync with android_media_AudioTrack.cpp
/**
* Creation mode where audio data is transferred from Java to the native layer
* only once before the audio starts playing.
*/
public static final int MODE_STATIC = 0;
/**
* Creation mode where audio data is streamed from Java to the native layer
* as the audio is playing.
*/
public static final int MODE_STREAM = 1;//最常见的形式audio数据被一部分一部分放到buffer中MODE_STATIC：
开始创建的时候，就把音频数据放到一个固定的buffer，然后直接传给audiotrack，后续就不用一次次得write了。AudioTrack会自己播放这个buffer中的数据。对应Native层的fastTrack，也就是latency playback 播放模式，FLAG对应于AUDIO_OUTPUT_FLAG_FAST；和Deep buffer Playback方式类似，但是它所分配的buffer更小些，并且在ADSP侧只做很少或者基本不做处理， 主要是播放一些对延迟要求较高的音频， 通常是Touchtone, gaming audio…
The static mode should be chosen when dealing with short sounds that fit in memory and that need to be played with the smallest latency possible.
MODE_STREAM:
In Streaming mode, the application writes a continuous stream of data to the AudioTrack, using write() methods.
These are blocking and return when the data has been transferred from the Java layer to the native layer and queued for playback. The streaming mode is most useful when playing blocks of audio data that for instance are:
1 too big to fit in memory because of the duration of the sound to play
2 too big to fit in memory because of the characteristics of the audio data(high sampling rate, bits per sample …)
3 received or generated while previously queued audio is playing.
/**
* Returns the current performance mode of the {@link AudioTrack}.
*
* @return one of {@link AudioTrack#PERFORMANCE_MODE_NONE},
* {@link AudioTrack#PERFORMANCE_MODE_LOW_LATENCY},
* or {@link AudioTrack#PERFORMANCE_MODE_POWER_SAVING}.
* Use {@link AudioTrack.Builder#setPerformanceMode}
* in the {@link AudioTrack.Builder} to enable a performance mode.
* @throws IllegalStateException if track is not initialized.
*/
public @PerformanceMode int getPerformanceMode() {
final int flags = native_get_flags();
if ((flags & AUDIO_OUTPUT_FLAG_FAST) != 0) {
return PERFORMANCE_MODE_LOW_LATENCY;
} else if ((flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) != 0) {
return PERFORMANCE_MODE_POWER_SAVING;
} else {
return PERFORMANCE_MODE_NONE;
}
}2. audio buffer
Upon creation, an AudioTrack object initializes its associated audio buffer.The size of this buffer, specified during the construction, determines how long an AudioTrack can play before running out of data.
For an AudioTrack using the static mode, this size is the maximum size of the sound that can be played from it.
For the streaming mode, data will be written to the audio sink in chunks of sizes less than or equal to the total buffer size.
getBufferSizeInFrames() : actual size in frames of the buffer created, which determines the minimum frequency to write to the streaming AudioTrack to avoid underrun.
getMinBufferSize() : determine the estimated minimum buffer size for an AudioTrack instance in streaming mode
3. 应用层AudioTrack的使用
应用层可以直接调用AudioTrack相关的api去播放pcm音频数据
// constants for test
final String TEST_NAME = "testSetBufferSize";
final int TEST_SR = 44100;//采样频率
final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; //双声道
final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;//一个采样点16比特
final int TEST_MODE = AudioTrack.MODE_STREAM;//通过write方式把数据一次一次得写到audiotrack的buffer中，比如通过编解码得到PCM数据，然后write到audiotrack
final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
// -------- initialization --------------
int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT,
minBuffSize, TEST_MODE);
track.play() ;//开始
...
track.write(bytes_pkg, 0, bytes_pkg.length) ;//往track中写数据
track.stop();//停止播放
track.release();//释放底层资源。注意：如果AudioTrack的创建形式是MODE_STATIC, 在play()执行前要先write() data. 而如果是MODE_STREAM，最初的data你可以在play前通过构造函数写到 bufferSizeInBytes中
If you don’t call write() first, or if you call write() but with an insufficient amount of
* data, then the track will be in underrun state at play(). In this case,
* playback will not actually start playing until the data path is filled to a
* device-specific minimum level. This requirement for the path to be filled
* to a minimum level is also true when resuming audio playback after calling stop().
* Similarly the buffer will need to be filled up again after
* the track underruns due to failure to call write() in a timely manner with sufficient data.
* For portability, an application should prime the data path to the maximum allowed
* by writing data until the write() method returns a short transfer count.
* This allows play() to start immediately, and reduces the chance of underrun.
更多的使用例子：
android/frameworks/base/media/jni/soundpool/SoundPool.cpp
关于write()
Writes the audio data to the audio sink for playback (streaming mode),
* or copies audio data for later playback (static buffer mode).
In streaming mode, the blocking behavior depends on the write mode. If the write mode is
WRITE_BLOCKING, the write will normally block until all the data has been enqueued for playback, and will return a full transfer count.
However, if the write mode is
*WRITE_NON_BLOCKING, or the track is stopped or paused on entry, or another thread interrupts the write by calling stop or pause, or an I/O error occurs during the write, then the write may return a short transfer count. In static buffer mode, copies the data to the buffer starting at offset 0,and the write mode is ignored.
关于StreamType
和Android中的AudioManager有关系，涉及到手机上的音频管理策略，具体等将 音频策略时详细解说
Android将系统的声音分为以下几类：
enum stream_type {
DEFAULT =-1, //
VOICE_CALL = 0, // 通话声
SYSTEM = 1, // 系统声, 低电,锁屏,开关机提示音等
RING = 2, // 来电铃声
MUSIC = 3, // 媒体播放声
ALARM = 4, // 闹铃
NOTIFICATION = 5, // 短信与通知
BLUETOOTH_SCO = 6, // 蓝牙通话
ENFORCED_AUDIBLE = 7, // 强制发声
DTMF = 8, // 拨号盘的按键音
TTS = 9, // 文本转语音, text to speech
FM = 10, // 调频声
NUM_STREAM_TYPES
};getMinBufferSize()
static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat)
int size = native_get_min_buff_size(sampleRateInHz, channelCount, audioFormat);
getMinBufferSize() 接口，字面意思是返回最小数据缓冲区的大小，它是声音能正常播放的最低保障，从函数参数来看，返回值取决于采样率、采样深度、声道数这三个属性。MODE_STREAM 模式下，应用程序重点参考其返回值然后确定分配多大的数据缓冲区。如果数据缓冲区分配得过小，那么播放声音会频繁遭遇 underrun，underrun 是指生产者（AudioTrack）提供数据的速度跟不上消费者（AudioFlinger::PlaybackThread）消耗数据的速度，反映到现实的后果就是声音断续卡顿，严重影响听觉体验。
4. Framework native层AudioTrack的创建
使用MediaPlayer播放音视频时，会创建AudioTrack对象用于播放音频数据
那么创建AudioTrack对象是什么时候创建的呢？
status_t MediaPlayerService::Client::setDataSource()
sp MediaPlayerService::Client::setDataSource_pre()
// create the right type of player
740 sp<MediaPlayerBase> p = createPlayer(playerType);
741 if (p == NULL) {
742 return p;
743 }
......
782 if (!p->hardwareOutput()) {
783 mAudioOutput = new AudioOutput(mAudioSessionId, IPCThreadState::self()->getCallingUid(),
784 mPid, mAudioAttributes);
//调用播放器的setAudioSink函数，把mAudioOutput对象赋值给相应播放器的AudioSink对象
785 static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
786 }
787
788 return p;android/frameworks/av/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
status_t NuPlayer::Renderer::onOpenAudioSink(){
......
1997 ALOGV("openAudioSink: try to open AudioSink in offload mode");
1998 uint32_t offloadFlags = flags;
1999 offloadFlags |= AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
2000 offloadFlags &= ~AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
2001 audioSinkChanged = true;
2002 mAudioSink->close();
2003
2004 err = mAudioSink->open(
2005 sampleRate,
2006 numChannels,
2007 (audio_channel_mask_t)channelMask,
2008 audioFormat,
2009 0 /* bufferCount - unused */,
2010 &NuPlayer::Renderer::AudioSinkCallback,
2011 this,
2012 (audio_output_flags_t)offloadFlags,
2013 &offloadInfo);
......
2047 if (!offloadOnly && !offloadingAudio()) {
2048 ALOGV("openAudioSink: open AudioSink in NON-offload mode");
2049 uint32_t pcmFlags = flags;
2050 pcmFlags &= ~AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;
}
......
2090 status_t err = mAudioSink->open(
2091 sampleRate,
2092 numChannels,
2093 (audio_channel_mask_t)channelMask,
2094 AVNuUtils::get()->getPCMFormat(format),
2095 0 /* bufferCount - unused */,
2096 mUseAudioCallback ? &NuPlayer::Renderer::AudioSinkCallback : NULL,
2097 mUseAudioCallback ? this : NULL,
2098 (audio_output_flags_t)pcmFlags,
2099 NULL,
2100 doNotReconnect,
2101 frameCount);
2102 if (err != OK) {
2103 ALOGW("openAudioSink: non offloaded open failed status: %d", err);
2104 mAudioSink->close();
2105 mCurrentPcmInfo = AUDIO_PCMINFO_INITIALIZER;
2106 return err;
2107 }
2108 mCurrentPcmInfo = info;
2109 if (!mPaused) { // for preview mode, don't start if paused
2110 mAudioSink->start();
2111 }
2112 }AudioTrack是在AudioOutput的open()中创建的，AudioOutput类是MediaPlayerService的内部类,还是继承自MediaPlayerBase::AudioSink的派生类
android/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp
status_t MediaPlayerService::AudioOutput::open(
1862 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1863 audio_format_t format, int bufferCount,
1864 AudioCallback cb, void *cookie,
1865 audio_output_flags_t flags,
1866 const audio_offload_info_t *offloadInfo,
1867 bool doNotReconnect,
1868 uint32_t suggestedFrameCount)
1869 {
......
1966 sp<AudioTrack> t;
1967 CallbackData *newcbd = NULL;
1968
1969 // We don't attempt to create a new track if we are recycling an
1970 // offloaded track. But, if we are recycling a non-offloaded or we
1971 // are switching where one is offloaded and one isn't then we create
1972 // the new track in advance so that we can read additional stream info
1973
1974 if (!(reuse && bothOffloaded)) {
1975 ALOGV("creating new AudioTrack");
1976
1977 if (mCallback != NULL) {
1978 newcbd = new CallbackData(this);
1979 t = new AudioTrack(
1980 mStreamType,
1981 sampleRate,
1982 format,
1983 channelMask,
1984 frameCount,
1985 flags,
1986 CallbackWrapper,
1987 newcbd,
1988 0, // notification frames
1989 mSessionId,
1990 AudioTrack::TRANSFER_CALLBACK,
1991 offloadInfo,
1992 mUid,
1993 mPid,
1994 mAttributes,
1995 doNotReconnect);
1996 } else {
1997 // TODO: Due to buffer memory concerns, we use a max target playback speed
1998 // based on mPlaybackRate at the time of open (instead of kMaxRequiredSpeed),
1999 // also clamping the target speed to 1.0 <= targetSpeed <= kMaxRequiredSpeed.
2000 const float targetSpeed =
2001 std::min(std::max(mPlaybackRate.mSpeed, 1.0f), kMaxRequiredSpeed);
2002 ALOGW_IF(targetSpeed != mPlaybackRate.mSpeed,
2003 "track target speed:%f clamped from playback speed:%f",
2004 targetSpeed, mPlaybackRate.mSpeed);
2005 t = new AudioTrack(
2006 mStreamType,
2007 sampleRate,
2008 format,
2009 channelMask,
2010 frameCount,
2011 flags,
2012 NULL, // callback
2013 NULL, // user data
2014 0, // notification frames
2015 mSessionId,
2016 AudioTrack::TRANSFER_DEFAULT,
2017 NULL, // offload info
2018 mUid,
2019 mPid,
2020 mAttributes,
2021 doNotReconnect,
2022 targetSpeed);
2023 }android/frameworks/av/media/libmediaplayerservice/nuplayer/NuPlayerRenderer.cpp
//将解码之后的音视频原始数据通知显示端并作缓存和同步
165 void NuPlayer::Renderer::queueBuffer(
166 bool audio,
167 const sp &buffer,
168 const sp ¬ifyConsumed) {
169 int64_t mediaTimeUs = -1;
170 buffer->meta()->findInt64(“timeUs”, &mediaTimeUs);
171 VTRACE_ASYNC_BEGIN(audio? “render-audio” : “render-video”, (int)mediaTimeUs);
172
173 sp msg = new AMessage(kWhatQueueBuffer, this);
174 msg->setInt32(“queueGeneration”, getQueueGeneration(audio));
175 msg->setInt32(“audio”, static_cast(audio));
176 msg->setObject(“buffer”, buffer);
177 msg->setMessage(“notifyConsumed”, notifyConsumed);
178 msg->post();
179 }
void NuPlayer::Renderer::onQueueBuffer(const sp &msg) {
void NuPlayer::Renderer::syncQueuesDone_l() {
http://makaidong.com/tocy/387821_1644854.html
AudioTrack is the hardware audio sink.
AudioSink is used for in-memory decode and potentially other applications where output doesn’t go straight to hardware.
注：AudioSink并不去做解码decoder的事情，它通过NuPlayRender获取解码后的数据，在open的时候获取AudioTrack对象mRecycledTrack或者创建新的AudioTrack，start时使用AudioTrack去播放解码后的PCM数据，并与AudioFlinger交互，将数据给到AudioFlinger做混音处理后由AudioFlinger交给AudioHardWare处理播放，AudioSink可以认为是一个“播放器”。
总之使用Mediaplayer播放音视频，实际由Nuplayer播放，使用NuplayerDecoder处理控制decoder，将解码的数据交给NuplayerRender通过queueBuffer获取原始音视频数据，对音视频原始数据缓存操作、音视频同步操作和其他辅助播放器控制的操作，在此过程中通过AudioSink去创建AudioTrack播放audio pcm数据
5. AudioTrack的处理
在android中播放声音可以用MediaPlayer和AudioTrack，MediaPlayer可以播放多种格式的声音文件，例如MP3，AAC，WAV，OGG，MIDI等, 而AudioTrack只能播放PCM数据流。但是两种方式本质上是一致的，MediaPlayer在播放音频时，在framework层还是会创建AudioTrack，把解码后的PCM数流传递给AudioTrack，由AudioFlinger进行混音，再将混音的数据给音频硬件播放出来。
几个音频概念
帧（frame）：帧表示一个完整的声音单元，所谓的声音单元是指一个采样样本；如果是双声道，那么一个完整的声音单元就是 2 个样本，如果是 5.1 声道，那么一个完整的声音单元就是 6 个样本了。帧的大小（一个完整的声音单元的数据量）等于声道数乘以采样深度，即 frameSize = channelCount * bytesPerSample。
传输延迟（latency）：Linux ALSA 把数据缓冲区划分为若干个块，dma 每传输完一个块上的数据即发出一个硬件中断，cpu 收到中断信号后，再配置 dma 去传输下一个块上的数据；一个块即是一个周期，周期大小（periodSize)即是一个数据块的帧数。再回到传输延迟（latency），传输延迟等于周期大小除以采样率，即 latency = periodSize / sampleRate。
音频重采样：音频重采样是指这样的一个过程——把一个采样率的数据转换为另一个采样率的数据。Android 原生系统上，音频硬件设备一般都工作在一个固定的采样率上（如 48 KHz），因此所有音轨数据都需要重采样到这个固定的采样率上，然后再输出。系统中可能存在多个音轨同时播放，而每个音轨的采样率可能是不一致的；比如在播放音乐的过程中，来了一个提示音，这时需要把音乐和提示音混音并输出到硬件设备，而音乐的采样率和提示音的采样率不一致，问题来了，如果硬件设备工作的采样率设置为音乐的采样率的话，那么提示音就会失真；因此最简单见效的解决方法是：硬件设备工作的采样率固定一个值，所有音轨在 AudioFlinger 都重采样到这个采样率上，混音后输出到硬件设备，保证所有音轨听起来都不失真。
AudioTrack::getMinFrameCount()
status_t AudioTrack::getMinFrameCount(
size_t* frameCount,
audio_stream_type_t streamType,
uint32_t sampleRate)
{
if (frameCount == NULL) {
return BAD_VALUE;
}
// 通过 binder 调用到 AudioFlinger::sampleRate()，取得硬件设备的采样率
uint32_t afSampleRate;
status_t status;
status = AudioSystem::getOutputSamplingRate(&afSampleRate, streamType);
if (status != NO_ERROR) {
ALOGE("Unable to query output sample rate for stream type %d; status %d",
streamType, status);
return status;
}
// 通过 binder 调用到 AudioFlinger::frameCount()，取得硬件设备的周期大小
size_t afFrameCount;
status = AudioSystem::getOutputFrameCount(&afFrameCount, streamType);
if (status != NO_ERROR) {
ALOGE("Unable to query output frame count for stream type %d; status %d",
streamType, status);
return status;
}
// 通过 binder 调用到 AudioFlinger::latency()，取得硬件设备的传输延迟
uint32_t afLatency;
status = AudioSystem::getOutputLatency(&afLatency, streamType);
if (status != NO_ERROR) {
ALOGE("Unable to query output latency for stream type %d; status %d",
streamType, status);
return status;
}
// When called from createTrack, speed is 1.0f (normal speed).
// This is rechecked again on setting playback rate (TODO: on setting sample rate, too).
// 根据 afSampleRate、afFrameCount、afLatency 计算出一个最低帧数
*frameCount = calculateMinFrameCount(afLatency, afFrameCount, afSampleRate, sampleRate, 1.0f);
// The formula above should always produce a non-zero value under normal circumstances:
// AudioTrack.SAMPLE_RATE_HZ_MIN <= sampleRate <= AudioTrack.SAMPLE_RATE_HZ_MAX.
// Return error in the unlikely event that it does not, as that's part of the API contract.
if (*frameCount == 0) {
ALOGE("AudioTrack::getMinFrameCount failed for streamType %d, sampleRate %u",
streamType, sampleRate);
return BAD_VALUE;
}
ALOGV("getMinFrameCount=%zu: afFrameCount=%zu, afSampleRate=%u, afLatency=%u",
*frameCount, afFrameCount, afSampleRate, afLatency);
return NO_ERROR;
}
// 有兴趣的可以研究 calculateMinFrameCount() 的实现，需大致了解重采样算法原理
static size_t calculateMinFrameCount(
uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate,
uint32_t sampleRate, float speed)
{
// Ensure that buffer depth covers at least audio hardware latency
uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate);
if (minBufCount < 2) {
minBufCount = 2;
}
ALOGV("calculateMinFrameCount afLatency %u afFrameCount %u afSampleRate %u "
"sampleRate %u speed %f minBufCount: %u",
afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount);
return minBufCount * sourceFramesNeededWithTimestretch(
sampleRate, afFrameCount, afSampleRate, speed);
}
static inline size_t sourceFramesNeededWithTimestretch(
uint32_t srcSampleRate, size_t dstFramesRequired, uint32_t dstSampleRate,
float speed) {
// required is the number of input frames the resampler needs
size_t required = sourceFramesNeeded(srcSampleRate, dstFramesRequired, dstSampleRate);
// to deliver this, the time stretcher requires:
return required * (double)speed + 1 + 1; // accounting for rounding dependencies
}
// Returns the source frames needed to resample to destination frames. This is not a precise
// value and depends on the resampler (and possibly how it handles rounding internally).
// Nevertheless, this should be an upper bound on the requirements of the resampler.
// If srcSampleRate and dstSampleRate are equal, then it returns destination frames, which
// may not be true if the resampler is asynchronous.
static inline size_t sourceFramesNeeded(
uint32_t srcSampleRate, size_t dstFramesRequired, uint32_t dstSampleRate) {
// +1 for rounding - always do this even if matched ratio (resampler may use phases not ratio)
// +1 for additional sample needed for interpolation
return srcSampleRate == dstSampleRate ? dstFramesRequired :
size_t((uint64_t)dstFramesRequired * srcSampleRate / dstSampleRate + 1 + 1);
}根据硬件设备的配置信息（采样率、周期大小、传输延迟）和音轨的采样率，计算出一个最低帧数
transfer_type
/* How data is transferred to AudioTrack
*/
149 enum transfer_type {
150 TRANSFER_DEFAULT, // not specified explicitly; determine from the other parameters
151 TRANSFER_CALLBACK, // callback EVENT_MORE_DATA
152 TRANSFER_OBTAIN, // call obtainBuffer() and releaseBuffer()
153 TRANSFER_SYNC, // synchronous write()
154 TRANSFER_SHARED, // shared memory
155 };AudioTrack的创建
上面我们讲过Frameork Native层 AudioTrack的创建，如下：
1976
1977 if (mCallback != NULL) {
1978 newcbd = new CallbackData(this);
1979 t = new AudioTrack(
1980 mStreamType,
1981 sampleRate,
1982 format,
1983 channelMask,
1984 frameCount,
1985 flags,
1986 CallbackWrapper,
1987 newcbd,
1988 0, // notification frames
1989 mSessionId,
1990 AudioTrack::TRANSFER_CALLBACK,//通过CALLBACK的方式将数据交给AudioTrack
1991 offloadInfo,
1992 mUid,
1993 mPid,
1994 mAttributes,
1995 doNotReconnect);那么先看AudioTrack.cpp的构造函数
android/frameworks/av/media/libaudioclient/AudioTrack.cpp
196 AudioTrack::AudioTrack(
197 audio_stream_type_t streamType,
198 uint32_t sampleRate,
199 audio_format_t format,
200 audio_channel_mask_t channelMask,
201 size_t frameCount,
202 audio_output_flags_t flags,
203 callback_t cbf,
204 void* user,
205 int32_t notificationFrames,
206 audio_session_t sessionId,
207 transfer_type transferType,
208 const audio_offload_info_t *offloadInfo,
209 uid_t uid,
210 pid_t pid,
211 const audio_attributes_t* pAttributes,
212 bool doNotReconnect,
213 float maxRequiredSpeed)
214 : mStatus(NO_INIT),
215 mState(STATE_STOPPED),
216 mPreviousPriority(ANDROID_PRIORITY_NORMAL),
217 mPreviousSchedulingGroup(SP_DEFAULT),
218 mPausedPosition(0),
219 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
220 mPortId(AUDIO_PORT_HANDLE_NONE)
221 {
222 mStatus = set(streamType, sampleRate, format, channelMask,
223 frameCount, flags, cbf, user, notificationFrames,
224 0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId, transferType,
225 offloadInfo, uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed);
226 }继续AudioTrack::set
289 status_t AudioTrack::set(
290 audio_stream_type_t streamType,
291 uint32_t sampleRate,
292 audio_format_t format,
293 audio_channel_mask_t channelMask,
294 size_t frameCount,
295 audio_output_flags_t flags,
296 callback_t cbf,
297 void* user,
298 int32_t notificationFrames,
299 const sp<IMemory>& sharedBuffer,
300 bool threadCanCallJava,
301 audio_session_t sessionId,
302 transfer_type transferType,
303 const audio_offload_info_t *offloadInfo,
304 uid_t uid,
305 pid_t pid,
306 const audio_attributes_t* pAttributes,
307 bool doNotReconnect,
308 float maxRequiredSpeed)
309 {
310 ...
315 mThreadCanCallJava = threadCanCallJava;
316
317 switch (transferType) {
318 case TRANSFER_DEFAULT:
319 if (sharedBuffer != 0) {
320 transferType = TRANSFER_SHARED;
321 } else if (cbf == NULL || threadCanCallJava) {
322 transferType = TRANSFER_SYNC;
323 } else {
324 transferType = TRANSFER_CALLBACK; // 构造函数调用时cbf ！= NULL && sharedBuffer == 0，采用callback回调方式
325 }
326 break;
327 case TRANSFER_CALLBACK: //检查参数是否合理
328 if (cbf == NULL || sharedBuffer != 0) {
329 ALOGE("Transfer type TRANSFER_CALLBACK but cbf == NULL || sharedBuffer != 0");
330 return BAD_VALUE;
331 }
332 break;
333 case TRANSFER_OBTAIN:
334 case TRANSFER_SYNC:
335 if (sharedBuffer != 0) {
336 ALOGE("Transfer type TRANSFER_OBTAIN but sharedBuffer != 0");
337 return BAD_VALUE;
338 }
339 break;
340 case TRANSFER_SHARED:
341 if (sharedBuffer == 0) {
342 ALOGE("Transfer type TRANSFER_SHARED but sharedBuffer == 0");
343 return BAD_VALUE;
344 }
345 break;
346 default:
347 ALOGE("Invalid transfer type %d", transferType);
348 return BAD_VALUE;
349 }
350 mSharedBuffer = sharedBuffer;
351 mTransfer = transferType;
352 mDoNotReconnect = doNotReconnect;
353
354 ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %zu", sharedBuffer->pointer(),
355 sharedBuffer->size());
356
357 ALOGV("set() streamType %d frameCount %zu flags %04x", streamType, frameCount, flags);
358
359 // invariant that mAudioTrack != 0 is true only after set() returns successfully
360 if (mAudioTrack != 0) {
361 ALOGE("Track already in use");
362 return INVALID_OPERATION;
363 }
364
365 // handle default values first.
366 if (streamType == AUDIO_STREAM_DEFAULT) {
367 streamType = AUDIO_STREAM_MUSIC;
368 }
369 if (pAttributes == NULL) {
370 if (uint32_t(streamType) >= AUDIO_STREAM_PUBLIC_CNT) {
371 ALOGE("Invalid stream type %d", streamType);
372 return BAD_VALUE;
373 }
374 mStreamType = streamType;
375
376 } else {
377 // stream type shouldn't be looked at, this track has audio attributes
378 memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));
379 ALOGV("Building AudioTrack with attributes: usage=%d content=%d flags=0x%x tags=[%s]",
380 mAttributes.usage, mAttributes.content_type, mAttributes.flags, mAttributes.tags);
381 mStreamType = AUDIO_STREAM_DEFAULT;
382 if ((mAttributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
383 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
384 }
385 if ((mAttributes.flags & AUDIO_FLAG_LOW_LATENCY) != 0) {
386 flags = (audio_output_flags_t) (flags | AUDIO_OUTPUT_FLAG_FAST);
387 }
388 // check deep buffer after flags have been modified above
389 if (flags == AUDIO_OUTPUT_FLAG_NONE && (mAttributes.flags & AUDIO_FLAG_DEEP_BUFFER) != 0) {
390 flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
391 }
392 }
393
394 // these below should probably come from the audioFlinger too...
395 if (format == AUDIO_FORMAT_DEFAULT) {
396 format = AUDIO_FORMAT_PCM_16_BIT;
397 } else if (format == AUDIO_FORMAT_IEC61937) { // HDMI pass-through?
398 mAttributes.flags |= AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;
399 }
400
401 // validate parameters
402 if (!audio_is_valid_format(format)) {
403 ALOGE("Invalid format %#x", format);
404 return BAD_VALUE;
405 }
406 mFormat = format;
407
408 if (!audio_is_output_channel(channelMask)) {
409 ALOGE("Invalid channel mask %#x", channelMask);
410 return BAD_VALUE;
411 }
412 mChannelMask = channelMask;
413 uint32_t channelCount = audio_channel_count_from_out_mask(channelMask);
414 mChannelCount = channelCount;
415
416 // force direct flag if format is not linear PCM
417 // or offload was requested
418 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
419 || !audio_is_linear_pcm(format)) {
420 ALOGV( (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
421 ? "Offload request, forcing to Direct Output"
422 : "Not linear PCM, forcing to Direct Output");
423 flags = (audio_output_flags_t)
424 // FIXME why can't we allow direct AND fast?
425 ((flags | AUDIO_OUTPUT_FLAG_DIRECT) & ~AUDIO_OUTPUT_FLAG_FAST);
426 }
427
428 // force direct flag if HW A/V sync requested
429 if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
430 flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
431 }
432
433 if (flags & AUDIO_OUTPUT_FLAG_DIRECT) {
434 if (audio_has_proportional_frames(format)) {
435 mFrameSize = channelCount * audio_bytes_per_sample(format);
436 } else {
437 mFrameSize = sizeof(uint8_t);
438 }
439 } else {
440 ALOG_ASSERT(audio_has_proportional_frames(format));
441 mFrameSize = channelCount * audio_bytes_per_sample(format);
442 // createTrack will return an error if PCM format is not supported by server,
443 // so no need to check for specific PCM formats here
444 }
445
446 // sampling rate must be specified for direct outputs
447 if (sampleRate == 0 && (flags & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
448 return BAD_VALUE;
449 }
450 mSampleRate = sampleRate;
451 mOriginalSampleRate = sampleRate;
452 mPlaybackRate = AUDIO_PLAYBACK_RATE_DEFAULT;
453 // 1.0 <= mMaxRequiredSpeed <= AUDIO_TIMESTRETCH_SPEED_MAX
454 mMaxRequiredSpeed = min(max(maxRequiredSpeed, 1.0f), AUDIO_TIMESTRETCH_SPEED_MAX);
455
456 // Make copy of input parameter offloadInfo so that in the future:
457 // (a) createTrack_l doesn't need it as an input parameter
458 // (b) we can support re-creation of offloaded tracks
459 if (offloadInfo != NULL) {
460 mOffloadInfoCopy = *offloadInfo;
461 mOffloadInfo = &mOffloadInfoCopy;
462 } else {
463 mOffloadInfo = NULL;
464 memset(&mOffloadInfoCopy, 0, sizeof(audio_offload_info_t));
465 }
466
467 mVolume[AUDIO_INTERLEAVE_LEFT] = 1.0f;
468 mVolume[AUDIO_INTERLEAVE_RIGHT] = 1.0f;
469 mSendLevel = 0.0f;
470 // mFrameCount is initialized in createTrack_l
471 mReqFrameCount = frameCount;
472 if (notificationFrames >= 0) {
473 mNotificationFramesReq = notificationFrames;
474 mNotificationsPerBufferReq = 0;
475 } else {
476 if (!(flags & AUDIO_OUTPUT_FLAG_FAST)) {
477 ALOGE("notificationFrames=%d not permitted for non-fast track",
478 notificationFrames);
479 return BAD_VALUE;
480 }
481 if (frameCount > 0) {
482 ALOGE("notificationFrames=%d not permitted with non-zero frameCount=%zu",
483 notificationFrames, frameCount);
484 return BAD_VALUE;
485 }
486 mNotificationFramesReq = 0;
487 const uint32_t minNotificationsPerBuffer = 1;
488 const uint32_t maxNotificationsPerBuffer = 8;
489 mNotificationsPerBufferReq = min(maxNotificationsPerBuffer,
490 max((uint32_t) -notificationFrames, minNotificationsPerBuffer));
491 ALOGW_IF(mNotificationsPerBufferReq != (uint32_t) -notificationFrames,
492 "notificationFrames=%d clamped to the range -%u to -%u",
493 notificationFrames, minNotificationsPerBuffer, maxNotificationsPerBuffer);
494 }
495 mNotificationFramesAct = 0;
496 if (sessionId == AUDIO_SESSION_ALLOCATE) {
497 mSessionId = (audio_session_t) AudioSystem::newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
498 } else {
499 mSessionId = sessionId;
500 }
501 int callingpid = IPCThreadState::self()->getCallingPid();
502 int mypid = getpid();
503 if (uid == AUDIO_UID_INVALID || (callingpid != mypid)) {
504 mClientUid = IPCThreadState::self()->getCallingUid();
505 } else {
506 mClientUid = uid;
507 }
508 if (pid == -1 || (callingpid != mypid)) {
509 mClientPid = callingpid;
510 } else {
511 mClientPid = pid;
512 }
513 mAuxEffectId = 0;
514 mOrigFlags = mFlags = flags;
515 mCbf = cbf;
516 //创建AudioTrackThread
517 if (cbf != NULL) {
518 mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
519 mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/);
520 // thread begins in paused state, and will not reference us until start()
521 }
522
523 // create the IAudioTrack
524 status_t status = createTrack_l();
525
526 if (status != NO_ERROR) {
527 if (mAudioTrackThread != 0) {
528 mAudioTrackThread->requestExit(); // see comment in AudioTrack.h
529 mAudioTrackThread->requestExitAndWait();
530 mAudioTrackThread.clear();
531 }
532 return status;
533 }
534
535 mStatus = NO_ERROR;
536 mUserData = user;
537 mLoopCount = 0;
538 mLoopStart = 0;
539 mLoopEnd = 0;
540 mLoopCountNotified = 0;
541 mMarkerPosition = 0;
542 mMarkerReached = false;
543 mNewPosition = 0;
544 mUpdatePeriod = 0;
545 mPosition = 0;
546 mReleased = 0;
547 mStartUs = 0;
548 AudioSystem::acquireAudioSessionId(mSessionId, mClientPid);
549 mSequence = 1;
550 mObservedSequence = mSequence;
551 mInUnderrun = false;
552 mPreviousTimestampValid = false;
553 mTimestampStartupGlitchReported = false;
554 mRetrogradeMotionReported = false;
555 mPreviousLocation = ExtendedTimestamp::LOCATION_INVALID;
556 mStartTs.mPosition = 0;
557 mUnderrunCountOffset = 0;
558 mFramesWritten = 0;
559 mFramesWrittenServerOffset = 0;
560 mFramesWrittenAtRestore = -1; // -1 is a unique initializer.
561 mVolumeHandler = new VolumeHandler();
562 return NO_ERROR;
563 }这里设置了提供音频数据的回调函数，启动AudioTrackThread线程来提供音频数据；调用 createTrack_l() 创建 IAudioTrack
AudioTrackThread
2991 bool AudioTrack::AudioTrackThread::threadLoop()
2992 {
2993 {
2994 AutoMutex _l(mMyLock);
2995 if (mPaused) {
2996 mMyCond.wait(mMyLock);
2997 // caller will check for exitPending()
2998 return true;
2999 }
3000 if (mIgnoreNextPausedInt) {
3001 mIgnoreNextPausedInt = false;
3002 mPausedInt = false;
3003 }
3004 if (mPausedInt) {
3005 if (mPausedNs > 0) {
3006 (void) mMyCond.waitRelative(mMyLock, mPausedNs);
3007 } else {
3008 mMyCond.wait(mMyLock);
3009 }
3010 mPausedInt = false;
3011 return true;
3012 }
3013 }
3014 if (exitPending()) {
3015 return false;
3016 }
3017 nsecs_t ns = mReceiver.processAudioBuffer();
3018 switch (ns) {
3019 case 0:
3020 return true;
3021 case NS_INACTIVE:
3022 pauseInternal();
3023 return true;
3024 case NS_NEVER:
3025 return false;
3026 case NS_WHENEVER:
3027 // Event driven: call wake() when callback notifications conditions change.
3028 ns = INT64_MAX;
3029 // fall through
3030 default:
3031 LOG_ALWAYS_FATAL_IF(ns < 0, "processAudioBuffer() returned %" PRId64, ns);
3032 pauseInternal(ns);
3033 return true;
3034 }
3035 }再来看mReceiver.processAudioBuffer()做什么,mReceiver就是AudioTrack本身
nsecs_t AudioTrack::processAudioBuffer()
{
......
//如果还有音频流没有写完
while (mRemainingFrames > 0) {
Buffer audioBuffer;
audioBuffer.frameCount = mRemainingFrames;
size_t nonContig;
//向共享内存块申请 一块可用的 buffer.
status_t err = obtainBuffer(&audioBuffer, requested, NULL, &nonContig);
....
}根据共享内存的读写指针的位置，判断当前处于什么样的状态，其中通过mCbf对象回调的状态值定义在 /frameworks/av/include/media/AudioTrack.h 的枚举event_type中：
/* Events used by AudioTrack callback function (callback_t).
* Keep in sync with frameworks/base/media/java/android/media/AudioTrack.java NATIVE_EVENT_*.
*/
enum event_type {
EVENT_MORE_DATA = 0, //需要更多的数据
EVENT_UNDERRUN = 1, //处于低负荷状态，目前不能提供更多的数据
EVENT_LOOP_END = 2, //循环结束
EVENT_MARKER = 3, //播放音频流达到警戒线
EVENT_NEW_POS = 4, // Playback head is at a new position
// (See setPositionUpdatePeriod()).
EVENT_BUFFER_END = 5, // Playback has completed for a static track.
EVENT_NEW_IAUDIOTRACK = 6, // IAudioTrack was re-created, either due to re-routing and
// voluntary invalidation by mediaserver, or mediaserver crash.
EVENT_STREAM_END = 7, //播放结束
// back (after stop is called) for an offloaded track.
#if 0 // FIXME not yet implemented
EVENT_NEW_TIMESTAMP = 8, // Delivered periodically and when there's a significant change
// in the mapping from frame position to presentation time.
// See AudioTimestamp for the information included with event.
#endif
};mCbf对象在AudioTrack的set()时传入
创建 IAudioTrack
在AudioTrack的set()函数中调用 createTrack_l() 创建 IAudioTrack
再来看 IAudioTrack的创建，需要先获取 audioFlinger的代理对象
// must be called with mLock held
status_t AudioTrack::createTrack_l()
{
//通过AudioSystem来获取 audioFlinger的代理对象，这样就可以通过它来实现业务需求
const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
if (audioFlinger == 0) {
ALOGE("Could not get audioflinger");
return NO_INIT;
}
if (mDeviceCallback != 0 && mOutput != AUDIO_IO_HANDLE_NONE) {
AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mOutput);
}
//这是一个很重要的变量，output相当于服务端线程的一个索引，
//客户端会根据这个来找到相应的音频输出线程
audio_io_handle_t output;
audio_stream_type_t streamType = mStreamType;
audio_attributes_t *attr = (mStreamType == AUDIO_STREAM_DEFAULT) ? &mAttributes : NULL;
//1. 根据参数来确定output值，其实这里调用到服务端去了
status_t status;
status = AudioSystem::getOutputForAttr(attr, &output,
(audio_session_t)mSessionId, &streamType, mClientUid,
mSampleRate, mFormat, mChannelMask,
mFlags, mSelectedDeviceId, mOffloadInfo);
//... 获取服务端 输出线程处理此类音频流 各种音频参数是多少...
// Client decides whether the track is TIMED (see below), but can only express a preference
// for FAST. Server will perform additional tests.
if ((mFlags & AUDIO_OUTPUT_FLAG_FAST) && !((
// either of these use cases:
// use case 1: shared buffer
(mSharedBuffer != 0) ||
// use case 2: callback transfer mode
(mTransfer == TRANSFER_CALLBACK) ||
// use case 3: obtain/release mode
(mTransfer == TRANSFER_OBTAIN)) &&
// matching sample rate
(mSampleRate == mAfSampleRate))) {
ALOGW("AUDIO_OUTPUT_FLAG_FAST denied by client; transfer %d, track %u Hz, output %u Hz",
mTransfer, mSampleRate, mAfSampleRate);
// once denied, do not request again if IAudioTrack is re-created
mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_FAST);
}
// The client's AudioTrack buffer is divided into n parts for purpose of wakeup by server, where
// n = 1 fast track with single buffering; nBuffering is ignored
// n = 2 fast track with double buffering
// n = 2 normal track, (including those with sample rate conversion)
// n >= 3 very high latency or very small notification interval (unused).
const uint32_t nBuffering = 2;
mNotificationFramesAct = mNotificationFramesReq;
//frameCount的计算 ...
// trackFlags 的设置 .... 省略
size_t temp = frameCount; // temp may be replaced by a revised value of frameCount,
// but we will still need the original value also
int originalSessionId = mSessionId;
//2. 调用服务端 createTrack，返回 IAudioTrack 接口，
//在stream模式下sharedBuffer为空，output为AudioFlinger中播放线程的id号
sp<IAudioTrack> track = audioFlinger->createTrack(streamType,
mSampleRate,
mFormat,
mChannelMask,
&temp,
&trackFlags,
mSharedBuffer,
output,
tid,
&mSessionId,
mClientUid,
&status);
ALOGE_IF(originalSessionId != AUDIO_SESSION_ALLOCATE && mSessionId != originalSessionId,
"session ID changed from %d to %d", originalSessionId, mSessionId);
if (status != NO_ERROR) {
ALOGE("AudioFlinger could not create track, status: %d", status);
goto release;
}
ALOG_ASSERT(track != 0);
// AudioFlinger now owns the reference to the I/O handle,
// so we are no longer responsible for releasing it.
//AudioFlinger创建Tack对象时会分配一块共享内存，这里得到这块共享内存的代理对象BpMemory
//获取音频流控制块，IMemory是一个对共享内存操作的跨进程操作接口
sp<IMemory> iMem = track->getCblk();
if (iMem == 0) {
ALOGE("Could not get control block");
return NO_INIT;
}
void *iMemPointer = iMem->pointer();
if (iMemPointer == NULL) {
ALOGE("Could not get control block pointer");
return NO_INIT;
}
// invariant that mAudioTrack != 0 is true only after set() returns successfully
if (mAudioTrack != 0) {
IInterface::asBinder(mAudioTrack)->unlinkToDeath(mDeathNotifier, this);
mDeathNotifier.clear();
}
//将创建的Track代理对象、匿名共享内存代理对象保存到AudioTrack的成员变量中
mAudioTrack = track;
mCblkMemory = iMem;
IPCThreadState::self()->flushCommands();
//将首地址强转为 audio_track_cblk_t ，这个对象以后的文章在分析，这里只要知道这个对象是对共 //享内存进行管理的结构体
//保存匿名共享内存的首地址。在匿名共享内存的头部存放了一个audio_track_cblk_t对象
audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMemPointer);
mCblk = cblk;
// note that temp is the (possibly revised) value of frameCount
if (temp < frameCount || (frameCount == 0 && temp == 0)) {
// In current design, AudioTrack client checks and ensures frame count validity before
// passing it to AudioFlinger so AudioFlinger should not return a different value except
// for fast track as it uses a special method of assigning frame count.
ALOGW("Requested frameCount %zu but received frameCount %zu", frameCount, temp);
}
frameCount = temp;
mAwaitBoost = false;
if (mFlags & AUDIO_OUTPUT_FLAG_FAST) {
if (trackFlags & IAudioFlinger::TRACK_FAST) {
ALOGV("AUDIO_OUTPUT_FLAG_FAST successful; frameCount %zu", frameCount);
mAwaitBoost = true;
} else {
ALOGV("AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %zu", frameCount);
// once denied, do not request again if IAudioTrack is re-created
mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_FAST);
}
}
if (mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
if (trackFlags & IAudioFlinger::TRACK_OFFLOAD) {
ALOGV("AUDIO_OUTPUT_FLAG_OFFLOAD successful");
} else {
ALOGW("AUDIO_OUTPUT_FLAG_OFFLOAD denied by server");
mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
// FIXME This is a warning, not an error, so don't return error status
//return NO_INIT;
}
}
if (mFlags & AUDIO_OUTPUT_FLAG_DIRECT) {
if (trackFlags & IAudioFlinger::TRACK_DIRECT) {
ALOGV("AUDIO_OUTPUT_FLAG_DIRECT successful");
} else {
ALOGW("AUDIO_OUTPUT_FLAG_DIRECT denied by server");
mFlags = (audio_output_flags_t) (mFlags & ~AUDIO_OUTPUT_FLAG_DIRECT);
// FIXME This is a warning, not an error, so don't return error status
//return NO_INIT;
}
}
// Make sure that application is notified with sufficient margin before underrun
if (mSharedBuffer == 0 && audio_is_linear_pcm(mFormat)) {
// Theoretically double-buffering is not required for fast tracks,
// due to tighter scheduling. But in practice, to accommodate kernels with
// scheduling jitter, and apps with computation jitter, we use double-buffering
// for fast tracks just like normal streaming tracks.
if (mNotificationFramesAct == 0 || mNotificationFramesAct > frameCount / nBuffering) {
mNotificationFramesAct = frameCount / nBuffering;
}
}
// We retain a copy of the I/O handle, but don't own the reference
mOutput = output;
mRefreshRemaining = true;
// Starting address of buffers in shared memory. If there is a shared buffer, buffers
// is the value of pointer() for the shared buffer, otherwise buffers points
// immediately after the control block. This address is for the mapping within client
// address space. AudioFlinger::TrackBase::mBuffer is for the server address space.
void* buffers;
if (mSharedBuffer == 0) {
buffers = cblk + 1;
} else {
buffers = mSharedBuffer->pointer();
if (buffers == NULL) {
ALOGE("Could not get buffer pointer");
return NO_INIT;
}
}
mAudioTrack->attachAuxEffect(mAuxEffectId);
// FIXME doesn't take into account speed or future sample rate changes (until restoreTrack)
// FIXME don't believe this lie
mLatency = mAfLatency + (1000*frameCount) / mSampleRate;
mFrameCount = frameCount;
// If IAudioTrack is re-created, don't let the requested frameCount
// decrease. This can confuse clients that cache frameCount().
if (frameCount > mReqFrameCount) {
mReqFrameCount = frameCount;
}
// reset server position to 0 as we have new cblk.
mServer = 0;
// 记住当 mSharedBuffer == 0 时时Stream模式
if (mSharedBuffer == 0) {
mStaticProxy.clear();
mProxy = new AudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize);
} else {
mStaticProxy = new StaticAudioTrackClientProxy(cblk, buffers, frameCount, mFrameSize);
mProxy = mStaticProxy;
}
//通过mProxy设置音频的相关参数的初始值
return status;
}我们知道，AudioPolicyService启动时载入了系统支持的全部音频接口。而且打开了默认的音频输出。打开音频输出时，调用AudioFlinger::openOutput()函数为当前打开的音频输出接口创建一个PlaybackThread线程，同一时候为该线程分配一个全局唯一的audio_io_handle_t值，并以键值对的形式保存在AudioFlinger的成员变量mPlaybackThreads中。在这里首先依据音频參数通过调用AudioSystem::getOutput()函数得到当前音频输出接口的PlaybackThread线程id号。同一时候传递给createTrack函数用于创建Track。
AudioTrack在AudioFlinger中是以Track来管理的。不过由于它们之间是跨进程的关系，因此须要一个“桥梁”来维护，这个沟通的媒介是IAudioTrack。函数createTrack_l除了为AudioTrack在AudioFlinger中申请一个Track外。还会建立两者间IAudioTrack桥梁。
IAudioTrack建立了AudioTrack与AudioFlinger之间的关系，在static模式下，用于存放音频数据的匿名共享内存在AudioTrack这边创建。在stream播放模式下，匿名共享内存却是在AudioFlinger这边创建。这两种播放模式下创建的匿名共享内存是有差别的，stream模式下的匿名共享内存头部会创建一个audio_track_cblk_t对象，用于协调生产者AudioTrack和消费者AudioFlinger之间的步调。createTrack就是在AudioFlinger中创建一个Track对象。
扫一扫
557
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
