Android视频播放数据读取的流程

转自 http://blog.sina.com.cn/foreverlovelost
这里分析Android4.0.1本地视频数据读取的流程，其他过程类似

当播放条件准备妥当之后，就要循环进行读取视频的原始数据放到MediaBuffer，将MediaBuffer中的数据输送到解码器中解码，解码后的数据放到MediaBuffer中，在将这MediaBuffer中的数据进行render显示。

本文主要侧重读取原始数据的流程，主要是代码跟踪，不夹杂个人分析，有些mpeg4的算法不懂。

1：onVideoEvent中开始读取数据，具体代码如下：

void AwesomePlayer::onVideoEvent() {
if (!mVideoBuffer) {
MediaSource::ReadOptions options;
if (mSeeking != NO_SEEK) {
LOGV("seeking to %lld us (%.2f secs)", mSeekTimeUs, mSeekTimeUs /1E6);

options.setSeekTo(
mSeekTimeUs,
mSeeking == SEEK_VIDEO_ONLY
?MediaSource::ReadOptions::SEEK_NEXT_SYNC
:MediaSource::ReadOptions::SEEK_CLOSEST_SYNC);
}
for (;;) {
status_terr =mVideoSource->read(&mVideoBuffer,&options);
}
}
}

蓝色为核心代码，如果是正常读取，options为null，否则这个结构体中包含了seek到的时间和seek的模式，用于具体从文件中哪里开始读取，传入的mVideoBuffer引用用来装解码后的数据

2：蓝色部分调用的是OMXCodec::read函数，这个函数中核心的代码如下：

status_t OMXCodec::read(
MediaBuffer **buffer, const ReadOptions*options) {
status_t err = OK;
*buffer = NULL;
bool seeking = false;
int64_t seekTimeUs;
ReadOptions::SeekModeseekMode;
if (options&&options->getSeekTo(&seekTimeUs,&seekMode)) {
seeking = true;
}

if (seeking) {
CODEC_LOGV("seeking to %lld us (%.2f secs)",seekTimeUs, seekTimeUs / 1E6);
CHECK(seekTimeUs >= 0);
mSeekTimeUs = seekTimeUs;
mSeekMode = seekMode;
}

drainInputBuffers();

size_t index = *mFilledBuffers.begin(); // A list of indices intomPortStatus[kPortIndexOutput] filled with data.
mFilledBuffers.erase(mFilledBuffers.begin());

BufferInfo *info =&mPortBuffers[kPortIndexOutput].editItemAt(index);
CHECK_EQ((int)info->mStatus,(int)OWNED_BY_US);
info->mStatus= OWNED_BY_CLIENT;

info->mMediaBuffer->add_ref();
*buffer = info->mMediaBuffer;

return OK;
}

两点：
a，drainInputBuffers开始了数据的读取；
b，mFilledBuffers从这个队列中读取已经解码后的数据放入到传入的MediaBuffer中，mFilledBuffers队列中的MediaBuffer就是drainInputBuffers中写进去的

3：跟到drainInputBuffer中看看

bool OMXCodec::drainInputBuffer(BufferInfo *info) {
CODEC_LOGV("callingemptyBuffer with codec specific data");
status_t err =mOMX->emptyBuffer(
mNode,info->mBuffer, 0, size,
OMX_BUFFERFLAG_ENDOFFRAME |OMX_BUFFERFLAG_CODECCONFIG,
0);
CHECK_EQ(err,(status_t)OK);
info->mStatus= OWNED_BY_COMPONENT;

status_t err;
bool signalEOS = false;
int64_t timestampUs =0;
size_t offset = 0;
int32_t n = 0;

for (;;) {
MediaBuffer *srcBuffer;
if (mSeekTimeUs >= 0) {
MediaSource::ReadOptions options;
options.setSeekTo(mSeekTimeUs, mSeekMode);

mSeekTimeUs = -1;
mSeekMode= ReadOptions::SEEK_CLOSEST_SYNC;
err =mSource->read(&srcBuffer,&options);

if (err ==OK) {
int64_t targetTimeUs;
if(srcBuffer->meta_data()->findInt64(
kKeyTargetTime,&targetTimeUs)
&& targetTimeUs >=0) {
CODEC_LOGV("targetTimeUs = %lld us",targetTimeUs);
mTargetTimeUs = targetTimeUs;
} else {
mTargetTimeUs = -1;
}
}
}
}

CODEC_LOGV("CallingemptyBuffer on buffer %p (length %d), "
"timestamp %lld us (%.2fsecs)",
info->mBuffer,offset,
timestampUs, timestampUs /1E6);
err = mOMX->emptyBuffer(
mNode, info->mBuffer, 0,offset,
flags, timestampUs);
info->mStatus= OWNED_BY_COMPONENT;
return true;
}

两点：
a，调用err= mSource->read(&srcBuffer,&options);从原始文件中读取原始数据，
b，往srcBuffer中读取数据前后，都调用omx转移已经读取到该info中的数据，目的是解码，解码后的数据就房子了mFilledBuffers这个队列中；

4：针对mpeg4类型的视频，上面的read函数调用的是MPEG4Source的read函数，核心代码如下：

status_t MPEG4Source::read(
MediaBuffer **out, constReadOptions *options) {
*out =NULL;

int64_tseekTimeUs;
ReadOptions::SeekMode mode;
if(options &&options->getSeekTo(&seekTimeUs,&mode)) {

if分支是用于有seek的流程
1：首先找到seektime附近的sampleIndex；
2：然后找到sampleIndex附近的关键帧的syncSampleIndex；
3：然后syncSampleIndex找到具体的sampleTime，sampleTime就是目前需要播放到的位置；
4：mSampleTable->getMetaDataForSample调用这个函数找到sampleTime时间的offset和size；
5：有了offset和size之后剩下就是调用mDataSource->readAt(offset,(uint8_t *)mBuffer->data(),size);读取数据放到buffer中去了；

uint32_t findFlags =0;
switch (mode) {
caseReadOptions::SEEK_PREVIOUS_SYNC:
findFlags= SampleTable::kFlagBefore;
break;
case ReadOptions::SEEK_NEXT_SYNC:
findFlags= SampleTable::kFlagAfter;
break;
caseReadOptions::SEEK_CLOSEST_SYNC:
case ReadOptions::SEEK_CLOSEST:
findFlags= SampleTable::kFlagClosest;
break;
default:
CHECK(!"Should not be here.");
break;
}

uint32_tsampleIndex;
status_t err =mSampleTable->findSampleAtTime(
seekTimeUs* mTimescale / 1000000,
&sampleIndex, findFlags);

uint32_tsyncSampleIndex;
if (err == OK) {
err =mSampleTable->findSyncSampleNear(
sampleIndex,&syncSampleIndex, findFlags);
}

uint32_tsampleTime;
if (err == OK) {
err =mSampleTable->getMetaDataForSample(
sampleIndex, NULL, NULL,&sampleTime);
}

if (mode ==ReadOptions::SEEK_CLOSEST) {
targetSampleTimeUs = (sampleTime * 1000000ll) /mTimescale;
}

mCurrentSampleIndex =syncSampleIndex;
}

off64_toffset;
size_tsize;
uint32_t cts;
boolisSyncSample;
boolnewBuffer = false;
if(mBuffer == NULL) {
newBuffer =true;

status_t err =
mSampleTable->getMetaDataForSample(
mCurrentSampleIndex,&offset, &size,&cts, &isSyncSample);

if (err != OK) {
return err;
}

err =mGroup->acquire_buffer(&mBuffer);

if (err != OK) {
CHECK(mBuffer == NULL);
return err;
}
}

if(!mIsAVC || mWantsNALFragments) {
if (newBuffer) {
ssize_t num_bytes_read =
mDataSource->readAt(offset, (uint8_t*)mBuffer->data(), size);

CHECK(mBuffer != NULL);
mBuffer->set_range(0,size);
mBuffer->meta_data()->clear();
mBuffer->meta_data()->setInt64(
kKeyTime, ((int64_t)cts *1000000) / mTimescale);

if (isSyncSample) {
mBuffer->meta_data()->setInt32(kKeyIsSyncFrame,1);
}

++mCurrentSampleIndex;
}

if (!mIsAVC) {
*out = mBuffer;
mBuffer = NULL;

return OK;
}

// Each NAL unit is split upinto its constituent fragments and
// each one of them returnedin its own buffer.

CHECK(mBuffer->range_length() >=mNALLengthSize);

const uint8_t *src=
(const uint8_t *)mBuffer->data()+ mBuffer->range_offset();

size_t nal_size =parseNALSize(src);

MediaBuffer *clone =mBuffer->clone();
CHECK(clone !=NULL);
clone->set_range(mBuffer->range_offset()+ mNALLengthSize, nal_size);

CHECK(mBuffer !=NULL);
mBuffer->set_range(
mBuffer->range_offset() + mNALLengthSize +nal_size,
mBuffer->range_length() - mNALLengthSize -nal_size);

if(mBuffer->range_length() == 0) {
mBuffer->release();
mBuffer = NULL;
}

*out = clone;

return OK;
}
}

蓝色部分为主要的流程

5：后续就是开始调用SampleTable.cpp和SampleIterator.cpp这两个类的相关函数解析文件和读取数据，最主要的函数时通过sampleIndex获取offset和size信息了，代码如下：

status_t SampleTable::getMetaDataForSample(

uint32_t sampleIndex,

off64_t *offset,

size_t *size,

uint32_t *compositionTime,

bool *isSyncSample) {

Mutex::AutolockautoLock(mLock);

status_t err;

if ((err =mSampleIterator->seekTo(sampleIndex)) != OK) {

return err;

}

if (offset) {
*offset =mSampleIterator->getSampleOffset();

}

if (size) {
*size =mSampleIterator->getSampleSize();

}

if (compositionTime) {
*compositionTime
=mSampleIterator->getSampleTime();

}

if (isSyncSample) {

*isSyncSample = false;

if (mSyncSampleOffset < 0){

// Everysample is a sync sample.

*isSyncSample = true;

} else {

size_t i =(mLastSyncSampleIndex < mNumSyncSamples)

&&(mSyncSamples[mLastSyncSampleIndex] <=sampleIndex)

? mLastSyncSampleIndex :0;

while (i< mNumSyncSamples &&mSyncSamples[i] < sampleIndex) {

++i;

}

if (i< mNumSyncSamples &&mSyncSamples[i] == sampleIndex) {
*isSyncSample
= true;

}

mLastSyncSampleIndex = i;

}

}

return OK;

}

下面这个函数没有看懂，对具体的mpeg4压缩协议没有进行深入了解

status_tSampleIterator::findSampleTime(
uint32_t sampleIndex,uint32_t *time) {
if(sampleIndex >=mTable->mNumSampleSizes) {
returnERROR_OUT_OF_RANGE;
}

while(sampleIndex >= mTTSSampleIndex + mTTSCount){
if (mTimeToSampleIndex ==mTable->mTimeToSampleCount) {
return ERROR_OUT_OF_RANGE;
}

mTTSSampleIndex +=mTTSCount;
mTTSSampleTime += mTTSCount *mTTSDuration;

mTTSCount =mTable->mTimeToSample[2 *mTimeToSampleIndex];
mTTSDuration =mTable->mTimeToSample[2 * mTimeToSampleIndex +1];

++mTimeToSampleIndex;
}

*time =mTTSSampleTime + mTTSDuration * (sampleIndex -mTTSSampleIndex);

*time+=mTable->getCompositionTimeOffset(sampleIndex);

returnOK;
}