Android(安卓)Audio AudioTrack::write函数

在最初的代码testWriteByte中，创建完AudioTrack对象后，调用了AudioTrack对象的write函数实现播放。
今天就来看看write函数的实现。

*****************************************源码*************************************************
public int write(byte[] audioData,int offsetInBytes, int sizeInBytes) {
if ((mDataLoadMode == MODE_STATIC)
&& (mState == STATE_NO_STATIC_DATA)
&& (sizeInBytes > 0)) {
mState = STATE_INITIALIZED;
}

if (mState != STATE_INITIALIZED) {
return ERROR_INVALID_OPERATION;
}

if ( (audioData == null) || (offsetInBytes < 0 ) || (sizeInBytes < 0)
|| (offsetInBytes + sizeInBytes > audioData.length)) {
return ERROR_BAD_VALUE;
}

return native_write_byte(audioData, offsetInBytes, sizeInBytes, mAudioFormat);
}
**********************************************************************************************
源码路径：
frameworks\base\media\java\android\media\AudioTrack.java

#################说明################################################
/**
* Writes the audio data to the audio hardware for playback.
* @param audioData the array that holds the data to play.
* @param offsetInBytes the offset expressed in bytes in audioData where the data to play
* starts.
* @param sizeInBytes the number of bytes to read in audioData after the offset.
* @return the number of bytes that were written or {@link #ERROR_INVALID_OPERATION}
* if the object wasn't properly initialized, or {@link #ERROR_BAD_VALUE} if
* the parameters don't resolve to valid data and indexes.
*/
// 先看看注释，有一点需要注意，offsetInBytes是指要播放的数据是从参数audioData的哪个地方开始
public int write(byte[] audioData,int offsetInBytes, int sizeInBytes) {
if ((mDataLoadMode == MODE_STATIC)
&& (mState == STATE_NO_STATIC_DATA)
&& (sizeInBytes > 0)) {
mState = STATE_INITIALIZED;
}

if (mState != STATE_INITIALIZED) {
return ERROR_INVALID_OPERATION;
}

if ( (audioData == null) || (offsetInBytes < 0 ) || (sizeInBytes < 0)
|| (offsetInBytes + sizeInBytes > audioData.length)) {
return ERROR_BAD_VALUE;
}

// 前面主要检查了状态及参数，真正干活的在native中。
return native_write_byte(audioData, offsetInBytes, sizeInBytes, mAudioFormat);
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
路径：frameworks\base\core\jni\android_media_AudioTrack.cpp
对应的native侧的函数为android_media_AudioTrack_native_write，其实现如下：
static jint android_media_AudioTrack_native_write(JNIEnv *env, jobject thiz,
jbyteArray javaAudioData,
jint offsetInBytes, jint sizeInBytes,
jint javaAudioFormat) {
jbyte* cAudioData = NULL;
AudioTrack *lpTrack = NULL;
//LOGV("android_media_AudioTrack_native_write(offset=%d, sizeInBytes=%d) called",
// offsetInBytes, sizeInBytes);

// get the audio track to load with samples
// 我们创建AudioTrack对象的时间将其保存到了java侧，
// 现在要使用它了，所以把它取出来
lpTrack = (AudioTrack *)env->GetIntField(thiz, javaAudioTrackFields.nativeTrackInJavaObj);
if (lpTrack == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"Unable to retrieve AudioTrack pointer for write()");
return 0;
}

// get the pointer for the audio data from the java array
if (javaAudioData) {
cAudioData = (jbyte *)env->GetPrimitiveArrayCritical(javaAudioData, NULL);
if (cAudioData == NULL) {
LOGE("Error retrieving source of audio data to play, can't play");
return 0; // out of memory or no data to load
}
} else {
LOGE("NULL java array of audio data to play, can't play");
return 0;
}

jint written = writeToTrack(lpTrack, javaAudioFormat, cAudioData, offsetInBytes, sizeInBytes);

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
jint writeToTrack(AudioTrack* pTrack, jint audioFormat, jbyte* data,
jint offsetInBytes, jint sizeInBytes) {
// give the data to the native AudioTrack object (the data starts at the offset)
ssize_t written = 0;
// regular write() or copy the data to the AudioTrack's shared memory?
// 判断shareBuffer是否为0.
// 如果是stream模式，shareBuffer为0，即不需要共享内存，因为数据是播放的时候一次一次写过来的
// 如果是direct模式，需要共享内存，因为数据是开始一次写过来的，后来再播放的时候，只是去共享内存中取
if (pTrack->sharedBuffer() == 0) {
// stream模式的情况下，直接调用AudioTrack对象的write函数。
written = pTrack->write(data + offsetInBytes, sizeInBytes);
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ssize_t AudioTrack::write(const void* buffer, size_t userSize)
{
// 如果存在共享内存的话，说明不应该调到这儿来
if (mSharedBuffer != 0) return INVALID_OPERATION;

// 不要相信用户
if (ssize_t(userSize) < 0) {
// sanity-check. user is most-likely passing an error code.
LOGE("AudioTrack::write(buffer=%p, size=%u (%d)",
buffer, userSize, userSize);
return BAD_VALUE;
}

LOGV("write %p: %d bytes, mActive=%d", this, userSize, mActive);

ssize_t written = 0;
const int8_t *src = (const int8_t *)buffer;
Buffer audioBuffer;
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
看看Buffer的实现：
/* Create Buffer on the stack and pass it to obtainBuffer()
* and releaseBuffer().
*/

class Buffer
{
public:
enum {
MUTE = 0x00000001
};
uint32_t flags;
int channelCount;
int format;
size_t frameCount;
size_t size;
union {
void* raw;
short* i16;
int8_t* i8;
};
};
----------------------------------------------------------------

do {
audioBuffer.frameCount = userSize/frameSize();

// Calling obtainBuffer() with a negative wait count causes
// an (almost) infinite wait time.
// 获取写数据用的buffer
status_t err = obtainBuffer(&audioBuffer, -1);
if (err < 0) {
// out of buffers, return #bytes written
if (err == status_t(NO_MORE_BUFFERS))
break;
return ssize_t(err);
}
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount)
{
int active;
status_t result;
audio_track_cblk_t* cblk = mCblk;
uint32_t framesReq = audioBuffer->frameCount;
uint32_t waitTimeMs = (waitCount < 0) ? cblk->bufferTimeoutMs : WAIT_PERIOD_MS;

audioBuffer->frameCount = 0;
audioBuffer->size = 0;

// audio_track_cblk_t是个什么东东？其实，它是个蛮重要的东东。
// 之前，我们也有看到过。今天找一下它的准确诞生地
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
audio_track_cblk_t对象是在创建AudioTrack的时候创建的。
如果调到AudioTrack的构造函数，就不再说了。AudioTrack构造函数之后的调用关系如下：
1、AudioTrack的构造函数调用了函数AudioTrack::set。
mStatus = set(streamType, sampleRate, format, channels,
0, flags, cbf, user, notificationFrames,
sharedBuffer, false, sessionId);
2、函数AudioTrack::set调用了函数AudioTrack::createTrack。
// create the IAudioTrack
status_t status = createTrack(streamType, sampleRate, format, channelCount,
frameCount, flags, sharedBuffer, output, true);
3、函数AudioTrack::createTrack调用了函数AudioFlinger::createTrack。
sp<IAudioTrack> track = audioFlinger->createTrack(getpid(),
streamType,
sampleRate,
format,
channelCount,
frameCount,
((uint16_t)flags) << 16,
sharedBuffer,
output,
&mSessionId,
&status);
并对成员变量mCblk进行赋值。
mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer());
mCblk->flags |= CBLK_DIRECTION_OUT;
4、函数AudioFlinger::createTrack调用了函数AudioFlinger::PlaybackThread::createTrack_l。
track = thread->createTrack_l(client, streamType, sampleRate, format,
channelCount, frameCount, sharedBuffer, lSessionId, &lStatus);
5、函数AudioFlinger::PlaybackThread::createTrack_l中创建了AudioFlinger::PlaybackThread::Track对象。
track = new Track(this, client, streamType, sampleRate, format,
channelCount, frameCount, sharedBuffer, sessionId);
6、类AudioFlinger::PlaybackThread::Track，是类AudioFlinger::ThreadBase::TrackBase的子类。
7、最终的诞生地，在AudioFlinger::ThreadBase::TrackBase的构造函数中
mCblkMemory = client->heap()->allocate(size);
mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer());
----------------------------------------------------------------
uint32_t framesAvail = cblk->framesAvailable();
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
uint32_t audio_track_cblk_t::framesAvailable()
{
Mutex::Autolock _l(lock);
return framesAvailable_l();
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
uint32_t audio_track_cblk_t::framesAvailable_l()
{
uint64_t u = this->user;
uint64_t s = this->server;

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define CBLK_DIRECTION_MSK 0x0002
#define CBLK_DIRECTION_OUT 0x0002 // this cblk is for an AudioTrack
#define CBLK_DIRECTION_IN 0x0000 // this cblk is for an AudioRecord
----------------------------------------------------------------
// 可见，CBLK_DIRECTION_MSK和CBLK_DIRECTION_OUT是相同的
// 判断CBLK_DIRECTION_MSK，其实也就是判断CBLK_DIRECTION_OUT。
// 我们是用它来播放的，此处当然是CBLK_DIRECTION_OUT了。
if (flags & CBLK_DIRECTION_MSK) {
uint64_t limit = (s < loopStart) ? s : loopStart;
return limit + frameCount - u;
} else {
return frameCount + u - s;
}
}
----------------------------------------------------------------
}
----------------------------------------------------------------

// 此处会不断循环，直到framesAvail不为0
if (framesAvail == 0) {
cblk->lock.lock();
goto start_loop_here;
while (framesAvail == 0) {
active = mActive;
if (UNLIKELY(!active)) {
LOGV("Not active and NO_MORE_BUFFERS");
cblk->lock.unlock();
return NO_MORE_BUFFERS;
}
if (UNLIKELY(!waitCount)) {
cblk->lock.unlock();
return WOULD_BLOCK;
}
if (!(cblk->flags & CBLK_INVALID_MSK)) {
result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs));
}
if (cblk->flags & CBLK_INVALID_MSK) {
LOGW("obtainBuffer() track %p invalidated, creating a new one", this);
// no need to clear the invalid flag as this cblk will not be used anymore
cblk->lock.unlock();
goto create_new_track;
}
if (__builtin_expect(result!=NO_ERROR, false)) {
cblk->waitTimeMs += waitTimeMs;
if (cblk->waitTimeMs >= cblk->bufferTimeoutMs) {
// timing out when a loop has been set and we have already written upto loop end
// is a normal condition: no need to wake AudioFlinger up.
if (cblk->user < cblk->loopEnd) {
LOGW( "obtainBuffer timed out (is the CPU pegged?) %p "
"user=%08llx, server=%08llx", this, cblk->user, cblk->server);
//unlock cblk mutex before calling mAudioTrack->start() (see issue #1617140)
cblk->lock.unlock();
result = mAudioTrack->start();
if (result == DEAD_OBJECT) {
LOGW("obtainBuffer() dead IAudioTrack: creating a new one");
create_new_track:
result = createTrack(mStreamType, cblk->sampleRate, mFormat, mChannelCount,
mFrameCount, mFlags, mSharedBuffer, getOutput(), false);
if (result == NO_ERROR) {
cblk = mCblk;
cblk->bufferTimeoutMs = MAX_RUN_TIMEOUT_MS;
mAudioTrack->start();
}
}
cblk->lock.lock();
}
cblk->waitTimeMs = 0;
}

if (--waitCount == 0) {
cblk->lock.unlock();
return TIMED_OUT;
}
}
// read the server count again
start_loop_here:
framesAvail = cblk->framesAvailable_l();
}
cblk->lock.unlock();
}

// restart track if it was disabled by audioflinger due to previous underrun
if (cblk->flags & CBLK_DISABLED_MSK) {
cblk->flags &= ~CBLK_DISABLED_ON;
LOGW("obtainBuffer() track %p disabled, restarting", this);
mAudioTrack->start();
}

cblk->waitTimeMs = 0;

if (framesReq > framesAvail) {
framesReq = framesAvail;
}

uint64_t u = cblk->user;
uint64_t bufferEnd = cblk->userBase + cblk->frameCount;

if (u + framesReq > bufferEnd) {
framesReq = (uint32_t)(bufferEnd - u);
}

audioBuffer->flags = mMuted ? Buffer::MUTE : 0;
audioBuffer->channelCount = mChannelCount;
audioBuffer->frameCount = framesReq;
audioBuffer->size = framesReq * cblk->frameSize;
if (AudioSystem::isLinearPCM(mFormat)) {
audioBuffer->format = AudioSystem::PCM_16_BIT;
} else {
audioBuffer->format = mFormat;
}
audioBuffer->raw = (int8_t *)cblk->buffer(u);
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void* audio_track_cblk_t::buffer(uint64_t offset) const
{
return (int8_t *)this->buffers + (offset - userBase) * this->frameSize;
}
----------------------------------------------------------------
active = mActive;
return active ? status_t(NO_ERROR) : status_t(STOPPED);
}
----------------------------------------------------------------

size_t toWrite;

if (mFormat == AudioSystem::PCM_8_BIT && !(mFlags & AudioSystem::OUTPUT_FLAG_DIRECT)) {
// Divide capacity by 2 to take expansion into account
toWrite = audioBuffer.size>>1;
// 8 to 16 bit conversion
int count = toWrite;
int16_t *dst = (int16_t *)(audioBuffer.i8);
while(count--) {
*dst++ = (int16_t)(*src++^0x80) << 8;
}
} else {
toWrite = audioBuffer.size;
memcpy(audioBuffer.i8, src, toWrite);
src += toWrite;
}
userSize -= toWrite;
written += toWrite;

releaseBuffer(&audioBuffer);
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AudioTrack::releaseBuffer(Buffer* audioBuffer)
{
audio_track_cblk_t* cblk = mCblk;
cblk->stepUser(audioBuffer->frameCount);
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
uint64_t audio_track_cblk_t::stepUser(uint32_t frameCount)
{
uint64_t u = this->user;

u += frameCount;
// Ensure that user is never ahead of server for AudioRecord
if (flags & CBLK_DIRECTION_MSK) {
// If stepServer() has been called once, switch to normal obtainBuffer() timeout period
if (bufferTimeoutMs == MAX_STARTUP_TIMEOUT_MS-1) {
bufferTimeoutMs = MAX_RUN_TIMEOUT_MS;
}
} else if (u > this->server) {
LOGW("stepServer occured after track reset");
u = this->server;
}

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

this->user = u;

// Clear flow control error condition as new data has been written/read to/from buffer.
flags &= ~CBLK_UNDERRUN_MSK;

return u;
}
----------------------------------------------------------------
}
----------------------------------------------------------------
} while (userSize);

return written;
}
----------------------------------------------------------------
} else {
// direct模式的话，将数据copy到共享内存。
// 注意，如果格式为PCM8，需要做下处理
if (audioFormat == javaAudioTrackFields.PCM16) {
// writing to shared memory, check for capacity
if ((size_t)sizeInBytes > pTrack->sharedBuffer()->size()) {
sizeInBytes = pTrack->sharedBuffer()->size();
}
memcpy(pTrack->sharedBuffer()->pointer(), data + offsetInBytes, sizeInBytes);
written = sizeInBytes;
} else if (audioFormat == javaAudioTrackFields.PCM8) {
// data contains 8bit data we need to expand to 16bit before copying
// to the shared memory
// writing to shared memory, check for capacity,
// note that input data will occupy 2X the input space due to 8 to 16bit conversion
if (((size_t)sizeInBytes)*2 > pTrack->sharedBuffer()->size()) {
sizeInBytes = pTrack->sharedBuffer()->size() / 2;
}
int count = sizeInBytes;
int16_t *dst = (int16_t *)pTrack->sharedBuffer()->pointer();
const int8_t *src = (const int8_t *)(data + offsetInBytes);
while(count--) {
*dst++ = (int16_t)(*src++^0x80) << 8;
}
// even though we wrote 2*sizeInBytes, we only report sizeInBytes as written to hide
// the 8bit mixer restriction from the user of this function
written = sizeInBytes;
}
}
return written;

}
----------------------------------------------------------------

env->ReleasePrimitiveArrayCritical(javaAudioData, cAudioData, 0);

//LOGV("write wrote %d (tried %d) bytes in the native AudioTrack with offset %d",
// (int)written, (int)(sizeInBytes), (int)offsetInBytes);
return written;
}
----------------------------------------------------------------
}
###################################################################

&&&&&&&&&&&总结&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1、写播放数据，其实最终写到了一个audio_track_cblk_t结构体中。
2、audio_track_cblk_t结构体在AudioFlinger中的TrackBase类的构造函数中创建。
创建的时候首先从Client申请一块内存，然后将内存地址强制转换成audio_track_cblk_t的指针。
结构体audio_track_cblk_t的最后一个成员便是指向数据的指针。
3、至此，只是将数据写到了AudioFlinger，AudioFling如何使用这些数据，最终实现播放，还需要继续学习。
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

更多相关文章

随机推荐