MP4文件sample读取流程_mp4getsampletime-CSDN博客

原文出处： http://blog.sina.com.cn/s/blog_645b74b90101g1on.html

前面两篇博客描述了MP4文件的boxer组成结构，各个boxer的含义和包含的文件信息；另外也描述了stts, stco, stsz, stsc, ctts等boxer是如何建立一张张用于查找各个sample具体位置，sample大小，时间和sampleIndex的对应关系的表，通过这些表，我们将一个MP4文件的所有的sample有机的组成在了一起，可以任意读取文件按特定sample或者特定时刻的内容。

这篇博客是建立在上几篇博客的基础上，我们想分析一个MP4文件已经解析完成后，如何利用这些表在文件中找到我们需要的sample的offset和size，然后读取送到解码器解码播放的，这里我们以Android libstagefright库中的MPEG4Extractor.cpp类为例。

在类MPEG4Extractor中，从文件中读取具体sample的过程是在函数read中完成，由于真实的场景的复杂性，读取sample的可能性多种多样，如从前往后播放是按照sampleIndex的顺序从前往后读；我们也可能随意拖动进度条，做seek操作，直接需要读取到某一特定时间点。但是，无论哪种场景最后流程大致一致，通过sampleIndex获取信息(offset, size, cts, isSyncFrame)，所以这里我们截取read函数的一种情况，拿出来分析，让我们明白如何在一个MP4文件中找到我们所需要的所有信息。

截取出来的部分关键代码如下，以红色部分标出：

status_t MPEG4Source::read(

MediaBuffer **out, const ReadOptions *options) {

Mutex::Autolock autoLock(mLock);

*out = NULL;

int64_t targetSampleTimeUs = -1;

off64_t offset;

size_t size;

uint32_t cts;

bool isSyncSample;

status_t err = mSampleTable->getMetaDataForSample

(mCurrentSampleIndex, &offset, &size, &cts, &isSyncSample);

err = mGroup->acquire_buffer(&mBuffer);

ssize_t num_bytes_read =mDataSource->readAt(offset, (uint8_t *)mBuffer->data(), size);

mBuffer->set_range(0, size);

mBuffer->meta_data()->clear();

mBuffer->meta_data()->setInt64(kKeyTime, ((int64_t)cts * 1000000) / mTimescale);

if (targetSampleTimeUs >= 0) {

mBuffer->meta_data()->setInt64(kKeyTargetTime, targetSampleTimeUs);

}

if (isSyncSample) {

mBuffer->meta_data()->setInt32(kKeyIsSyncFrame, 1);

}

++mCurrentSampleIndex;

*out = mBuffer;

mBuffer = NULL;

return OK;

}

最关键的函数就是 getMetaDataForSample 这个函数通过sampleIndex获取到该sample的offset，size和isSyncFrame等信息，有了offset和size就已经将这个sample的内容定位了，直接调用readAt读取即可，读取完会后将 mCurrentSampleIndex加一，表示下一个将要读取的sample的索引。

要知道如何通过sampleIndex获得这些信息，就需要继续跟踪函数 getMetaDataForSample

status_t SampleTable::getMetaDataForSample(

uint32_t sampleIndex,

off64_t *offset,

size_t *size,

uint32_t *compositionTime,

bool *isSyncSample) {

Mutex::Autolock autoLock(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) {

// Every sample 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;

}

蓝色部分是通过查询关键帧表，判断当前的sample是不是关键帧，if分支里面通过 mSyncSampleOffset < 0判断MP4文件中是否提供了一个stss的关键帧表，如果没有提供的话就默认所有的帧都是关键帧，如果提供了stss的关键帧表，则进入下面的else分支进行查询，通过前面的一篇博客对于关键帧boxer的解析过程，我们知道在SampleTable::setSyncSampleParams函数中记录三个东西：

mSyncSampleOffset = data_offset; sync boxer表的数据部分起始位置偏移

mNumSyncSamples = U32_AT(&header[4]);第五到八的四字节表示关键帧的数目，每个关键帧的序列号用四个字节表示

mSyncSamples = new uint32_t[mNumSyncSamples];

mDataSource->readAt(mSyncSampleOffset + 8, mSyncSamples, size)

用数组mSyncSamples记录每一个帧的序列号，即sampleIndex，我们这里就是通过后面两个变量判断当前帧是否是关键帧，算法如下：

mLastSyncSampleIndex是数组mSyncSamples中的游标，用来记录该数组中上次被取出的关键帧的个数，从mLastSyncSampleIndex开始计数，遍历数组，直到mSyncSamples[i] = sampleIndex（当前帧为关键帧的情况），或者数组遍历完没有找到等于sampleIndex的情况（当前帧不是关键帧）

当然大前提，i必须少于关键帧的总数这个条件一直都必须满足。

分析红色部分的代码，首先看后三个函数的实现：

off64_t getSampleOffset() const { return mCurrentSampleOffset; }

size_t getSampleSize() const { return mCurrentSampleSize; }

uint32_t getSampleTime() const { return mCurrentSampleTime; }

这三个函数相当简单，直接在头文件声明和定义，返回三个变量的值，没有任何逻辑操作，所以这三个变量肯定是在其他地方设置值的，也就是在上面的seekTo函数，这个函数非常关键，通过sampleIndex，设置各个变量的值，继续看seekTo的实现

status_t SampleIterator::seekTo(uint32_t sampleIndex) {

ALOGV("seekTo(%d)", sampleIndex);

if (sampleIndex >= mTable->mNumSampleSizes) {

return ERROR_END_OF_STREAM;

}

检查各个表有没有被初始化

if (mTable->mSampleToChunkOffset < 0

|| mTable->mChunkOffsetOffset < 0

|| mTable->mSampleSizeOffset < 0

|| mTable->mTimeToSampleCount == 0) {

return ERROR_MALFORMED;

}

if (mInitialized && mCurrentSampleIndex == sampleIndex) {

return OK;

}

if (!mInitialized || sampleIndex < mFirstChunkSampleIndex) {

reset();

}

if (sampleIndex >= mStopChunkSampleIndex) {

status_t err;

if ((err = findChunkRange(sampleIndex)) != OK) {

ALOGE("findChunkRange failed");

return err;

}

CHECK(sampleIndex < mStopChunkSampleIndex);

uint32_t chunk =

(sampleIndex - mFirstChunkSampleIndex) / mSamplesPerChunk

+ mFirstChunk;

if (!mInitialized || chunk != mCurrentChunkIndex) {

mCurrentChunkIndex = chunk;

status_t err;

if ((err = getChunkOffset(chunk, &mCurrentChunkOffset)) != OK) {

ALOGE("getChunkOffset return error");

return err;

}

mCurrentChunkSampleSizes .clear();

uint32_t firstChunkSampleIndex =

mFirstChunkSampleIndex

+ mSamplesPerChunk * (mCurrentChunkIndex - mFirstChunk);

for (uint32_t i = 0; i < mSamplesPerChunk; ++i) {

size_t sampleSize;

if ((err = getSampleSizeDirect(

firstChunkSampleIndex + i, &sampleSize)) != OK) {

ALOGE("getSampleSizeDirect return error");

return err;

}

mCurrentChunkSampleSizes .push(sampleSize);

}

uint32_t chunkRelativeSampleIndex =

(sampleIndex - mFirstChunkSampleIndex) % mSamplesPerChunk;

mCurrentSampleOffset = mCurrentChunkOffset;

for (uint32_t i = 0; i < chunkRelativeSampleIndex ; ++i) {

mCurrentSampleOffset += mCurrentChunkSampleSizes [i];

}

mCurrentSampleSize = mCurrentChunkSampleSizes [chunkRelativeSampleIndex ];

if (sampleIndex < mTTSSampleIndex) {

mTimeToSampleIndex = 0;

mTTSSampleIndex = 0;

mTTSSampleTime = 0;

mTTSCount = 0;

mTTSDuration = 0;

}

status_t err;

if ((err = findSampleTime(sampleIndex, &mCurrentSampleTime)) != OK) {

ALOGE("findSampleTime return error");

return err;

}

mCurrentSampleIndex = sampleIndex;

mInitialized = true;

return OK;

}

蓝色部分为入口参数的检查，这里直接忽略，全当正常情况，分析主要逻辑，由前面知，我们需要三个变量：

mCurrentSampleSize

mCurrentSampleTime

mCurrentSampleOffset

我们看这三个变量的赋值过程：

公式一：计算当前sample所在的chunk

sampleIndex - mFirstChunkSampleIndex

uint32_t chunk = ----------------------------------------------- + mFirstChunk

mSamplesPerChunk

公式二：查表计算当前chunk的偏移地址getChunkOffset(chunk, &mCurrentChunkOffset);

（以四字节表示的chunk offset为例）

mCurrentChunkOffset = ntohl(mTable->mDataSource->readAt(

mTable->mChunkOffsetOffset + 8 + 4 * chunk,

&offset32,

sizeof(offset32));

公式三：计算当前chunk的第一个sample的索引号firstChunkSampleIndex

firstChunkSampleIndex = mFirstChunkSampleIndex + mSamplesPerChunk * ( chunk - mFirstChunk);

公式四：计算这个chunk中每一个sample的大小，按照顺序放到数组mCurrentChunkSampleSizes中

for (uint32_t i = 0; i < mSamplesPerChunk; ++i) {

size_t sampleSize;

if ((err = getSampleSizeDirect(

firstChunkSampleIndex + i, &sampleSize)) != OK) {

ALOGE("getSampleSizeDirect return error");

return err;

}

mCurrentChunkSampleSizes.push(sampleSize);

}

其中计算sample的大小使用公式五

公式五：计算任意一个sampleIndex的size

（以其中的一种情况为例）

size = ntohl(mTable->mDataSource->readAt(mTable->mSampleSizeOffset + 12 + 4 * sampleIndex, size, sizeof(*size));

公式六：计算sample在当前chunk中是第几个sample

（这里应当有好几种方法）

uint32_t chunkRelativeSampleIndex =

( sampleIndex - mFirstChunkSampleIndex) % mSamplesPerChunk;

有了这些就可以计算上面三个变量中的两个了：

从sample大小的数组中取出当前sample的大小

mCurrentSampleSize = mCurrentChunkSampleSizes [chunkRelativeSampleIndex ];

当前sample的offset等于chunk的offset加上在这个chunk中位于这个sample之前的各个sample的大小和

mCurrentSampleOffset = mCurrentSampleOffset;

for (uint32_t i = 0; i < chunkRelativeSampleIndex ; ++i) {

mCurrentSampleOffset += mCurrentChunkSampleSizes [i];

}

变量mCurrentSampleTime和上面的处理无关，直接通过查找stts表得到：

status_t SampleIterator::findSampleTime(

uint32_t sampleIndex, uint32_t *time) {

if (sampleIndex >= mTable->mNumSampleSizes) {

return ERROR_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);

return OK;

}

分析上面这个函数之前，我们再次看下stts这个boxer解析的过程：

case FOURCC('s', 't', 't', 's'):

{

status_t err =

mLastTrack->sampleTable->setTimeToSampleParams(

data_offset, chunk_data_size);

*offset += chunk_size;

break;

}

status_t SampleTable::setTimeToSampleParams(

off64_t data_offset, size_t data_size) {

一个MP4文件中只能存在一个stts boxer，且其数据部分长度至少为8字节

if (mTimeToSample != NULL || data_size < 8) {

return ERROR_MALFORMED;

}

uint8_t header[8];

if (mDataSource->readAt(

data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {

return ERROR_IO;

}

if (U32_AT(header) != 0) { 前四个字节表示这个stts boxer的版本，为零

// Expected version = 0, flags = 0.

return ERROR_MALFORMED;

}

mTimeToSampleCount = U32_AT(&header[4]);

stts表中记录的time 2 sample的个数，每个记录占8个字节，分为两部分，每部分占用四个字节

mTimeToSample = new uint32_t[mTimeToSampleCount * 2];

建立一个数组，保存这些记录，至于为什么要乘以2可以参照上面的分析，因为每条记录占用八个字节，但是这八个字节分为两部分：前四字节表示sample的个数，后四字节表示这几个sample的时长，例如：

---------------------------------------------------------------------------------------

我要计算第五个记录的时长 duration = mTimeToSample[2*4] * mTimeToSample[2*4+1]

时长 = 数组中第五个记录对应的sample的个数(mTTSCount) * 每个sample的长度(mTTSDuration)

---------------------------------------------------------------------------------------

size_t size = sizeof(uint32_t) * mTimeToSampleCount * 2;

if (mDataSource->readAt(

data_offset + 8, mTimeToSample, size) < (ssize_t)size) {

return ERROR_IO;

}

for (uint32_t i = 0; i < mTimeToSampleCount * 2; ++i) {

mTimeToSample[i] = ntohl(mTimeToSample[i]);

}

return OK;

}

分析了setTimeToSampleParams函数之后，在来分析findSampleTime就非常清晰了，算法如下：

先看下以下几个变量的含义：

mTTSSampleIndex：stts表中遍历到当前sampleIndex所在的记录前的所有记录sample数目之和；

mTTSCount：stts表中每条记录中包含的sample的个数，后四个字节表示；

mTTSDuration：stts表中每条记录中每个sample的时长

mTTSSampleTime：stts表中每条记录占用的时长之和，求和符号（mTTSCount[i]*mTTSSampleTime[i]）；

mTimeToSampleIndex：stts表中数组mTimeToSample内部的游标，用来记录当前定位到第几个stts记录；

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;

}

遍历所有的stts记录（其实是到上一次遍历到的记录），并求mTTSSampleTime的时间，

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

当前sample的时间戳就是前面所有的记录的时间之和mTTSSampleTime在加上，剩余的stts中一条记录中的几个sample的时间之和（如果推出while循环的时候，刚好满足了=的条件，这里就为0）

最后在加上composition time就是最后的时间戳了,composition time没有具体看，应当是ctts生成的一个表，专门用来记录到达每一个sample的时候，delta time是多少，即时间的延迟，ctts和stts表的生成和读取流程是一模一样的，可以对照学习，下面将代码贴出，并作简要分析：

case FOURCC('c', 't', 't', 's'):

{

status_t err =

mLastTrack->sampleTable->setCompositionTimeToSamp leParams(

data_offset, chunk_data_size);

*offset += chunk_size;

break;

}

status_t SampleTable::setCompositionTimeToSamp leParams(

off64_t data_offset, size_t data_size) {

ALOGI("There are reordered frames present.");

if (mCompositionTimeDeltaEnt ries != NULL || data_size < 8) {

return ERROR_MALFORMED;

}

uint8_t header[8];

if (mDataSource->readAt(

data_offset, header, sizeof(header))

< (ssize_t)sizeof(header)) {

return ERROR_IO;

}

if ( U32_AT(header) != 0) {

// Expected version = 0, flags = 0.

return ERROR_MALFORMED;

}

size_t numEntries = U32_AT(&header[4]);

if (data_size != (numEntries + 1) * 8) {

return ERROR_MALFORMED;

}

mNumCompositionTimeDeltaEntries = numEntries;

mCompositionTimeDeltaEntries = new uint32_t[2 * numEntries];

if (mDataSource-> readAt(

data_offset + 8, mCompositionTimeDeltaEntries, numEntries * 8)

< (ssize_t)numEntries * 8) {

delete[] mCompositionTimeDeltaEnt ries;

mCompositionTimeDeltaEnt ries = NULL;

return ERROR_IO;

}

for (size_t i = 0; i < 2 * numEntries; ++i) {

mCompositionTimeDeltaEntries[i] = ntohl(mCompositionTimeDeltaEntries[i]);

}

mCompositionDeltaLookup->setEntries(

mCompositionTimeDeltaEntries, mNumCompositionTimeDeltaEntries);

return OK;

}

void SampleTable::CompositionDeltaLookup::setEntries(

const uint32_t *deltaEntries, size_t numDeltaEntries) {

Mutex::Autolock autolock(mLock);

mDeltaEntries = deltaEntries;

mNumDeltaEntries = numDeltaEntries;

mCurrentDeltaEntry = 0;

mCurrentEntrySampleIndex = 0;

}

任意sampleIndex，计算composition time的过程：

uint32_t SampleTable::getCompositionTimeOffset (uint32_t sampleIndex) {

return mCompositionDeltaLookup->getCompositionTimeOffset (sampleIndex);

}

uint32_t SampleTable::CompositionDeltaLookup::getCompositionTimeOffset (

uint32_t sampleIndex) {

Mutex::Autolock autolock(mLock);

if (mDeltaEntries == NULL) {

return 0;

}

if (sampleIndex < mCurrentEntrySampleIndex ) {

mCurrentDeltaEntry = 0;

mCurrentEntrySampleIndex = 0;

}

while (mCurrentDeltaEntry < mNumDeltaEntries) {

uint32_t sampleCount = mDeltaEntries[2 * mCurrentDeltaEntry]; 记录的前四字节表示sample的个数

if (sampleIndex < mCurrentEntrySampleIndex + sampleCount) {

return m DeltaEntries[2 * mCurrentDeltaEntry + 1];记录的后四个字节表示时间

}

mCurrentEntrySampleIndex += sampleCount; 数组内部每个记录对应的sampleIndex

++mCurrentDeltaEntry; m DeltaEntries数组内部的游标，用来遍历所有的记录

}

return 0;

}