当前位置: 代码迷 >> Android >> Android frameworkl源码 MPEG4Writer.cpp 简略跟读
  详细解决方案

Android frameworkl源码 MPEG4Writer.cpp 简略跟读

热度:785   发布时间:2016-04-28 00:06:09.0
Android frameworkl源码 MPEG4Writer.cpp 简单跟读

       首先在前面申明一点,本人接触Android的时间并不长,只是因为喜欢 Android开发,并且项目有需要,才会去看Android framework 层MPEG4Writer.cpp 的代码。在这里也只是想简单的记录下自己这几天跟读代码的结果,也好给自己个交代。其中有些知识还是感谢网上其它大神的指点,这里给出我参考的博文的链接点击打开链接 http://m.blog.csdn.net/blog/liwendovo/8478259。

    下面的一些内容和图片,我就不自己总结了,直接粘贴上面链接博文的内容:

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

Android系统录像封装流程主要有三个步骤:

1)       录制开始时,写入文件头部。

2)       录制进行时,实时写入音视频轨迹的数据块。

3)       录制结束时,写入索引信息并更新头部参数。

  索引负责描述音视频轨迹的特征,会随着音视频轨迹的存储而变化,所以通常做法会将录像文件索引信息放在音视频轨迹流后面,在媒体流数据写完(录像结束)后才能写入。可以看到,存放音视频数据的mdat box是位于第二位的,而负责检索音视频的moov box是位于最后的,这与通常的MP4封装的排列顺序不同,当然这是为了符合录制而产生的结果。因为 moov的大小是随着 mdat 变化的,而我们录制视频的时间预先是不知道的,所以需要先将mdat 数据写入,最后再写入moov,完成封装。 

  现有Android系统上录像都是录制是MP4或3GP格式,底层就是使用MPEG4Writer组合器类来完成的,它将编码后的音视频轨迹按照MPEG4规范进行封装,填入各个参数,就组合成完整的MP4格式文件。MPEG4Writer的组合功能主要由两种线程完成,一种是负责音视频数据写入封装文件的写线程(WriterThread),一种是音视频数据读取处理的轨迹线程(TrackThread)。轨迹线程一般有两个:视频轨迹数据读取线程和音频轨迹数据读取线程,而写线程只有一个,负责将轨迹线程中打包成Chunk的数据写入封装文件。

  如图3所示,轨迹线程是以帧为单位获取数据帧(Sample),并将每帧中的信息及系统环境信息提取汇总存储在内存的trak表中,其中需要维持的信息有Chunk写入文件的偏移地址Stco(Chunk Offset)、Sample与Chunk的映射关系Stsc(Sample-to-Chunk)、关键帧Stss(Sync Sample)、每一帧的持续时间Stts(Time-to-Sample)等,这些信息是跟每一帧的信息密切相关的,由图可以看出trak表由各自的线程维护,当录像结束时trak表会就会写入封装文件。而每一帧的数据流会先存入一个链表缓存中,当帧的数量达到一定值时,轨迹线程会将这些帧数据打包成块(Chunk)并通知写线程写入到封装文件。写线程接到Chunk已准备好的通知后就马上搜索Chunk链表(链表个数与轨迹线程个数相关,一般有两个,音视频轨迹线程各有一个),将找到的第一个Chunk后便写入封装文件,并会将写入的偏移地址更新到相应的trak表的Stco项(但trak表中其它数据是由轨迹线程更新)。音视频的Chunk数据是存储于同一mdat box中,按添加到Chunk链表时间先后顺序排列。等到录像结束时,录像应用会调用MPEG4Writer的stop方法,此时就会将音视频的trak表分别写入moov。

 

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

     其实看完上面的内容,应该对Android录制视频过程中,录制的视频的封装过程有一个大体了解,我们平时所说的视频后缀名.mp4/.mkv等等就是视频封装的各种格式。

     下面将给出MPEG4Writer.cpp 的跟读过程:

      MPEG4Writer.cpp 的构造函数,在这里将实现一些参数的初始化,fd是传进来的录制文件的文件描述符。

 MPEG4Writer::MPEG4Writer(int fd)    :<span style="background-color: rgb(204, 255, 255);"> mFd(dup(fd))</span>,      ifReRecording(false),      mInitCheck(mFd < 0? NO_INIT: OK),      mIsRealTimeRecording(true),      mUse4ByteNalLength(true),      mUse32BitOffset(true),      mIsFileSizeLimitExplicitlyRequested(false),      mPaused(false),      mStarted(false),      mWriterThreadStarted(false),      mOffset(0),      mMdatOffset(0),      mEstimatedMoovBoxSize(0),      mInterleaveDurationUs(1000000),      mLatitudex10000(0),      mLongitudex10000(0),      mAreGeoTagsAvailable(false),      mStartTimeOffsetMs(-1),      mHFRRatio(1) {            ALOGD("*** MPEG4Writer(int fd):mFd is:%d",mFd);	  }

     应用层 MediaRecorder.start();时,往framework层调用时,将会调用到MPEG4Writer.cpp 中的 start部分,在start部分,我们看到在这一部分,writeFtypBox(param) 将实现录制文件文件头部信息的相关信息的写入操作;startWriterThread() 开启封装视频文件的写线程;startTracks(param) 开启视频数据的读线程,也就是前面文件部分所说的轨迹线程。

status_t MPEG4Writer::start(MetaData *param) {          ......	//暂停后,再次start时,mStarted = true;mPaused = false;    if (mStarted) {        if (mPaused) {            mPaused = false;            return startTracks(param);         }        return OK;    }      ......   <span style="background-color: rgb(204, 255, 255);"> writeFtypBox(param);</span><span style="color:#ff0000;"> //写入封装文件头部信息</span>    mFreeBoxOffset = mOffset;      ......    mOffset = mMdatOffset;    <span style="background-color: rgb(204, 255, 255);"> lseek64(mFd, mMdatOffset, SEEK_SET);</span> <span style="color:#ff0000;">//将文件指针移动到mMdatOffset的位置</span>
        status_t err =<span style="background-color: rgb(204, 255, 255);"> startWriterThread()</span>;<span style="color:#ff0000;"> //开启写线程</span>
     <p>     if (err != OK) { return err; }</p><p>        err =<span style="background-color: rgb(204, 255, 255);"> startTracks(param);</span><span style="color: rgb(255, 0, 0);">//开启轨迹线程</span></p><p>      if (err != OK) { return err; }</p><p>      mStarted = true; return OK;}</p>


   继续看下 startWriterThread()部分,在startWriterThread()函数中,将真正建立新的子线程,并在子线程中执行ThreadWrappe函数中的操作。

status_t MPEG4Writer::startWriterThread() {    ALOGV("****** startWriterThread");    mDone = false;    mIsFirstChunk = true;    mDriftTimeUs = 0;    for (List<Track *>::iterator it = mTracks.begin();         it != mTracks.end(); ++it) {        ChunkInfo info;        info.mTrack = *it;        info.mPrevChunkTimestampUs = 0;        info.mMaxInterChunkDurUs = 0;        mChunkInfos.push_back(info);  //    }    pthread_attr_t attr;    pthread_attr_init(&attr);    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);    pthread_create(&mThread, &attr,<span style="background-color: rgb(102, 255, 255);">ThreadWrapper</span>, this);    pthread_attr_destroy(&attr);    mWriterThreadStarted = true;    return OK;}
    接着继续看 ThreadWrapper()函数,在这里new 了一个MPEGWriter对象,真正的操作在threadFunc()中体现

void *MPEG4Writer::ThreadWrapper(void *me) {    MPEG4Writer *writer = static_cast<MPEG4Writer *>(me);    writer->threadFunc();    return NULL;}
   下面看下threadFun()。在这个函数中,将根据变量mDone 进行while循环,一直检测是否有数据块Chunk可写。轨迹线程是一直将读数据的数据往buffer中写入,buffer到了一定量后,就是chunk,这时就会通过信号量 mChunkReadyCondition来通知封装文件的写线程去检测链表,然后将检索到的Chunk数据写入文件的数据区,当然写之前,肯定会去判断下是否真的有数据可写。

void MPEG4Writer::threadFunc() {    prctl(PR_SET_NAME, (unsigned long)"MPEG4Writer", 0, 0, 0);    Mutex::Autolock autoLock(mLock);    while (!mDone) {          Chunk chunk;        bool chunkFound = false;        while (!mDone && !(chunkFound = findChunkToWrite(&chunk))) {           <span style="background-color: rgb(255, 255, 255);"><span style="color:#ff0000;">mChunkReadyCondition</span></span>.wait(mLock);        }        // In real time recording mode, write without holding the lock in order        // to reduce the blocking time for media track threads.        // Otherwise, hold the lock until the existing chunks get written to the        // file.        if (chunkFound) {            if (mIsRealTimeRecording) {                mLock.unlock();            }            writeChunkToFile(&chunk);            if (mIsRealTimeRecording) {                mLock.lock();            }        }    }     <span style="background-color: rgb(204, 255, 255);"> writeAllChunks();</span>//<span style="background-color: rgb(255, 255, 255);"><span style="color:#ff0000;">这个是在while(!mDone)之后了,应用层MediaRecorder.stop()时,mDone的值将为true,这里应该是录制文件结束时,将剩下的所有数据都写入封装文件,具体也没有跟读。</span></span>}
    下面看下writerChunkToFile(&chunk);轨迹线程读数据时是以数据帧Sample为单位,所以这里将Chunk写入封装文件,也是以Sample为单位,遍历整个链表,将数据写入封装文件,真正的写入操作是addSamole_l(*it);

void MPEG4Writer::writeChunkToFile(Chunk* chunk) {    ALOGV("******writeChunkToFile: %lld from %s track",        chunk->mTimeStampUs, chunk->mTrack->isAudio()? "audio": "video");    int32_t isFirstSample = true;    while (!chunk->mSamples.empty()) {        List<MediaBuffer *>::iterator it = chunk->mSamples.begin();        off64_t offset = chunk->mTrack->isAvc()                                ? addLengthPrefixedSample_l(*it)                                :<span style="background-color: rgb(204, 255, 255);"> addSample_l(*it)</span>;        if (isFirstSample) {            chunk->mTrack->addChunkOffset(offset);            isFirstSample = false;        }        (*it)->release();        (*it) = NULL;        chunk->mSamples.erase(it);    }    chunk->mSamples.clear();}
   下面看下addSamole_l(*it) 函数,wirte写入操作,mFd 是上层设置录制的文件路径传下来的文件描述符

off64_t MPEG4Writer::addSample_l(MediaBuffer *buffer) {	    off64_t old_offset = mOffset;    ::write(mFd,          (const uint8_t *)buffer->data() + buffer->range_offset(),          buffer->range_length());    mOffset += buffer->range_length();    return old_offset;}
     到此,封装文件的写入线程的操作大体走完,下面看轨迹线程的操作。

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

   startTracks(param) 轨迹线程的开启。文件的录制过程中是有2条轨迹线程,一个是视频的轨迹线程,另一条则是音频的轨迹线程,在starTrack(param)中是在for 循环中start了两条轨迹线程。

status_t MPEG4Writer::startTracks(MetaData *params) {    if (mTracks.empty()) {        ALOGE("No source added");        return INVALID_OPERATION;    }    for (List<Track *>::iterator it = mTracks.begin();         it != mTracks.end(); ++it) {        status_t err =(*it)->start(params);        if (err != OK) {            for (List<Track *>::iterator it2 = mTracks.begin();                 it2 != it; ++it2) {                (*it2)->stop();            }            return err;        }    }    return OK;}
   (*it)->start(params) 将会执行status_t MPEG4Writer::Track::start(MetaData *params) {} 。在这边也是同样新建子线程,在子线程中执行轨迹线程的相应操作。

status_t MPEG4Writer::Track::start(MetaData *params) {      ......    pthread_attr_t attr;    pthread_attr_init(&attr);    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);    mDone = false;    mStarted = true;    mTrackDurationUs = 0;    mReachedEOS = false;    mEstimatedTrackSizeBytes = 0;    mMdatSizeBytes = 0;    mMaxChunkDurationUs = 0;    pthread_create(&mThread, &attr,<span style="background-color: rgb(204, 255, 255);">ThreadWrapper</span>, this);<span style="background-color: rgb(255, 0, 0);">//在子线程中执行ThreadWrapper函数</span>    pthread_attr_destroy(&attr);    mHFRRatio = ExtendedUtils::HFR::getHFRRatio(mMeta);    return OK;}
   下面看下上面ThreadWrapper函数,真正的操作又是放到了threadEntry()中去执行
void *MPEG4Writer::Track::ThreadWrapper(void *me) {    Track *track = static_cast<Track *>(me);    status_t err = track-><span style="background-color: rgb(102, 255, 255);">threadEntry</span>();    return (void *) err;}
    下面看thrck->threadEntry(),算是比较重要的一个函数了。有些具体的我自己也没看懂,只是知道到大概。

status_t MPEG4Writer::Track::threadEntry() {    ......    int64_t lastTimestampUs = 0;      // Previous sample time stamp    int64_t lastDurationUs = 0;       // Between the previous two samples    int64_t currDurationTicks = 0;    // Timescale based ticks    int64_t lastDurationTicks = 0;    // Timescale based ticks    int32_t sampleCount = 1;          // Sample count in the current stts table entry    uint32_t previousSampleSize = 0;  // Size of the previous sample    int64_t previousPausedDurationUs = 0;    int64_t timestampUs = 0;    int64_t cttsOffsetTimeUs = 0;    int64_t currCttsOffsetTimeTicks = 0;   // Timescale based ticks    int64_t lastCttsOffsetTimeTicks = -1;  // Timescale based ticks    int32_t cttsSampleCount = 0;           // Sample count in the current ctts table entry    uint32_t lastSamplesPerChunk = 0;     sp<MetaData> meta_data;    status_t err = OK;    MediaBuffer *buffer;    while (!mDone && (err =<span style="color:#ff0000;"> mSource->read(&buffer)</span>) == OK) { 
       <span style="color:#ff0000;">  //mSource->read(&buffer) 将会调用CameraSource.cpp中的相应接口,进行视频数据的读取</span>
</pre><pre name="code" class="cpp">        if (buffer->range_length() == 0) {            buffer->release();            buffer = NULL;            ++nZeroLengthFrames;            continue;        }        // If the codec specific data has not been received yet, delay pause.        // After the codec specific data is received, discard what we received        // when the track is to be paused.        if (mPaused && !mResumed) {            buffer->release();            buffer = NULL;            continue;        }        ++count;        int32_t isCodecConfig;  //???                if (buffer->meta_data()->findInt32(kKeyIsCodecConfig, &isCodecConfig)                && isCodecConfig) {            CHECK(!mGotAllCodecSpecificData);            if (mIsAvc) {                status_t err = makeAVCCodecSpecificData(                        (const uint8_t *)buffer->data()                            + buffer->range_offset(),                        buffer->range_length());                CHECK_EQ((status_t)OK, err);            } else if (mIsMPEG4) {                mCodecSpecificDataSize = buffer->range_length();                mCodecSpecificData = malloc(mCodecSpecificDataSize);                memcpy(mCodecSpecificData,                        (const uint8_t *)buffer->data()                            + buffer->range_offset(),                       buffer->range_length());            }            buffer->release();            buffer = NULL;            mGotAllCodecSpecificData = true;            continue;        }        // Make a deep copy of the MediaBuffer and Metadata and release        // the original as soon as we can        MediaBuffer *copy = new MediaBuffer(buffer->range_length());        memcpy(copy->data(), (uint8_t *)buffer->data() + buffer->range_offset(),                buffer->range_length());        copy->set_range(0, buffer->range_length());        meta_data = new MetaData(*buffer->meta_data().get());        buffer->release();        buffer = NULL;        if (mIsAvc) StripStartcode(copy);        size_t sampleSize = copy->range_length();        if (mIsAvc) {            if (mOwner->useNalLengthFour()) {                sampleSize += 4;            } else {                sampleSize += 2;            }        }        // Max file size or duration handling        mMdatSizeBytes += sampleSize;        updateTrackSizeEstimate();
        /*<span style="color:#ff0000;">写过视频录制的同学应该比较清楚,在上层应用,初始化MediaRecorder时,设置了录制文件录制的大小或者录制录制的段长时,为了实现循环录制,就需要监听底层的回调接口。而底层的回调就是在下面实现的。</span>
<span style="color:#ff0000;">exceedsFileSizeLimit()函数将会判断录制的文件的大小是否已经达到设置的大小,从而决定是否向上层回馈信息。同理exceedsFileDurationLimit()函数则是判断是否到达设置的段长。</span>
        */        if (mOwner-><span style="background-color: rgb(102, 255, 255);">exceedsFileSizeLimit()</span>) {            mOwner->notify(MEDIA_RECORDER_EVENT_INFO, <span style="color:#ff0000;">MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED</span>, 0);            break;        }		        if (mOwner-><span style="background-color: rgb(102, 255, 255);">exceedsFileDurationLimit()</span>) {            mOwner->notify(MEDIA_RECORDER_EVENT_INFO, <span style="color:#ff0000;">MEDIA_RECORDER_INFO_MAX_DURATION_REACHED</span>, 0);            			break;        }        int32_t isSync = false;        meta_data->findInt32(kKeyIsSyncFrame, &isSync);        CHECK(meta_data->findInt64(kKeyTime, ×tampUs));////////////////////////////////////////////////////////////////////////////////        if (mStszTableEntries->count() == 0) {            mFirstSampleTimeRealUs = systemTime() / 1000;            mStartTimestampUs = timestampUs;            mOwner->setStartTimestampUs(mStartTimestampUs);            previousPausedDurationUs = mStartTimestampUs;        }        if (mResumed) {            mResumed = false;        }        timestampUs -= previousPausedDurationUs;        CHECK_GE(timestampUs, 0ll);        if (!mIsAudio) {            /*             * Composition time: timestampUs             * Decoding time: decodingTimeUs             * Composition time offset = composition time - decoding time             */            int64_t decodingTimeUs;            CHECK(meta_data->findInt64(kKeyDecodingTime, &decodingTimeUs));            decodingTimeUs -= previousPausedDurationUs;            cttsOffsetTimeUs =                    timestampUs - decodingTimeUs;            CHECK_GE(kMaxCttsOffsetTimeUs, decodingTimeUs - timestampUs);            timestampUs = decodingTimeUs;            ALOGV("decoding time: %lld and ctts offset time: %lld",                timestampUs, cttsOffsetTimeUs);            // Update ctts box table if necessary            currCttsOffsetTimeTicks =                    (cttsOffsetTimeUs * mTimeScale + 500000LL) / 1000000LL;            CHECK_LE(currCttsOffsetTimeTicks, 0x0FFFFFFFFLL);            if (mStszTableEntries->count() == 0) {                // Force the first ctts table entry to have one single entry                // so that we can do adjustment for the initial track start                // time offset easily in writeCttsBox().                lastCttsOffsetTimeTicks = currCttsOffsetTimeTicks;                addOneCttsTableEntry(1, currCttsOffsetTimeTicks);                cttsSampleCount = 0;      // No sample in ctts box is pending            } else {                if (currCttsOffsetTimeTicks != lastCttsOffsetTimeTicks) {                    addOneCttsTableEntry(cttsSampleCount, lastCttsOffsetTimeTicks);                    lastCttsOffsetTimeTicks = currCttsOffsetTimeTicks;                    cttsSampleCount = 1;  // One sample in ctts box is pending                } else {                    ++cttsSampleCount;                }            }            // Update ctts time offset range            if (mStszTableEntries->count() == 0) {                mMinCttsOffsetTimeUs = currCttsOffsetTimeTicks;                mMaxCttsOffsetTimeUs = currCttsOffsetTimeTicks;            } else {                if (currCttsOffsetTimeTicks > mMaxCttsOffsetTimeUs) {                    mMaxCttsOffsetTimeUs = currCttsOffsetTimeTicks;                } else if (currCttsOffsetTimeTicks < mMinCttsOffsetTimeUs) {                    mMinCttsOffsetTimeUs = currCttsOffsetTimeTicks;                }            }        }        if (mOwner->isRealTimeRecording()) {            if (mIsAudio) {                updateDriftTime(meta_data);            }        }        CHECK_GE(timestampUs, 0ll);        ALOGV("%s media time stamp: %lld and previous paused duration %lld",                mIsAudio? "Audio": "Video", timestampUs, previousPausedDurationUs);        if (timestampUs > mTrackDurationUs) {            mTrackDurationUs = timestampUs;        }        // We need to use the time scale based ticks, rather than the        // timestamp itself to determine whether we have to use a new        // stts entry, since we may have rounding errors.        // The calculation is intended to reduce the accumulated        // rounding errors.        currDurationTicks =            ((timestampUs * mTimeScale + 500000LL) / 1000000LL -                (lastTimestampUs * mTimeScale + 500000LL) / 1000000LL);        if (currDurationTicks < 0ll) {            ALOGE("timestampUs %lld < lastTimestampUs %lld for %s track",                timestampUs, lastTimestampUs, mIsAudio? "Audio": "Video");            err = UNKNOWN_ERROR;            mSource->notifyError(err);            return err;        }        mStszTableEntries->add(htonl(sampleSize));        if (mStszTableEntries->count() > 2) {            // Force the first sample to have its own stts entry so that            // we can adjust its value later to maintain the A/V sync.            if (mStszTableEntries->count() == 3 || currDurationTicks != lastDurationTicks) {                addOneSttsTableEntry(sampleCount, lastDurationTicks);                sampleCount = 1;            } else {                ++sampleCount;            }        }        if (mSamplesHaveSameSize) {            if (mStszTableEntries->count() >= 2 && previousSampleSize != sampleSize) {                mSamplesHaveSameSize = false;            }            previousSampleSize = sampleSize;        }        ALOGV("%s timestampUs/lastTimestampUs: %lld/%lld",                mIsAudio? "Audio": "Video", timestampUs, lastTimestampUs);        lastDurationUs = timestampUs - lastTimestampUs;        lastDurationTicks = currDurationTicks;        lastTimestampUs = timestampUs;        if (isSync != 0) {            addOneStssTableEntry(mStszTableEntries->count());        }        if (mTrackingProgressStatus) {            if (mPreviousTrackTimeUs <= 0) {                mPreviousTrackTimeUs = mStartTimestampUs;            }            trackProgressStatus(timestampUs);        }        // use File write in seperate thread for video only recording        if (!hasMultipleTracks && mIsAudio) {            off64_t offset = mIsAvc? mOwner->addLengthPrefixedSample_l(copy)                                 : mOwner->addSample_l(copy);            uint32_t count = (mOwner->use32BitFileOffset()                        ? mStcoTableEntries->count()                        : mCo64TableEntries->count());            if (count == 0) {                addChunkOffset(offset);            }            copy->release();            copy = NULL;            continue;        }     <span style="background-color: rgb(102, 255, 255);"> mChunkSamples.push_back(copy);</span><span style="color:#ff0000;">//push_back 是将读取到的数据添加到数据块链表的尾部</span>		       ......    }    if (isTrackMalFormed()) {        err = ERROR_MALFORMED;    }    mOwner->trackProgressStatus(mTrackId, -1, err);    // Last chunk    if (!hasMultipleTracks && mIsAudio) {        addOneStscTableEntry(1, mStszTableEntries->count());    } else if (!mChunkSamples.empty()) {        addOneStscTableEntry(++nChunks, mChunkSamples.size());        bufferChunk(timestampUs);    }    // We don't really know how long the last frame lasts, since    // there is no frame time after it, just repeat the previous    // frame's duration.    if (mStszTableEntries->count() == 1) {        lastDurationUs = 0;  // A single sample's duration        lastDurationTicks = 0;    } else {        ++sampleCount;  // Count for the last sample    }    if (mStszTableEntries->count() <= 2) {        addOneSttsTableEntry(1, lastDurationTicks);        if (sampleCount - 1 > 0) {            addOneSttsTableEntry(sampleCount - 1, lastDurationTicks);        }    } else {        addOneSttsTableEntry(sampleCount, lastDurationTicks);    }    // The last ctts box may not have been written yet, and this    // is to make sure that we write out the last ctts box.    if (currCttsOffsetTimeTicks == lastCttsOffsetTimeTicks) {        if (cttsSampleCount > 0) {            addOneCttsTableEntry(cttsSampleCount, lastCttsOffsetTimeTicks);        }    }    mTrackDurationUs += lastDurationUs;    mReachedEOS = true;    sendTrackSummary(hasMultipleTracks);    ALOGI("Received total/0-length (%d/%d) buffers and encoded %d frames. - %s",            count, nZeroLengthFrames, mStszTableEntries->count(), mIsAudio? "audio": "video");    if (mIsAudio) {        ALOGI("Audio track drift time: %lld us", mOwner->getDriftTimeUs());    }    if (err == ERROR_END_OF_STREAM) {        return OK;    }    return err;}
------------------------------------------------------------------------------------------------------------

     下面看下,录制文件结束时的一些操作。录制文件结束时,上层应用分别是调用 MediaRecorder的stop()、reset()release()方法,下面看下MPEG4Writer.cpp中相对应的操作。

status_t MPEG4Writer::Track::stop() {    if (!mStarted) {        ALOGE("Stop() called but track is not started");        return ERROR_END_OF_STREAM;    }    if (mDone) {        return OK;    }    mDone = true;    void *dummy;  <span style="background-color: rgb(51, 255, 255);"> pthread_join(mThread, &dummy)</span>;//等待mThread 的结束    status_t err = (status_t) dummy;    ALOGD("Stopping %s track source", mIsAudio? "Audio": "Video");    {        status_t status = mSource->stop();        if (err == OK && status != OK && status != ERROR_END_OF_STREAM) {            err = status;        }    }    ALOGD("%s track stopped", mIsAudio? "Audio": "Video");    return err;}

  reset()函数中将完成轨迹线程、写入线程的停止、封装文件尾部信息的写入等操作

status_t MPEG4Writer::reset() {    if (mInitCheck != OK) {        return OK;    } else {        if (!mWriterThreadStarted ||            !mStarted) {            if (mWriterThreadStarted) {                stopWriterThread();            }            release();            return OK;        }    }    status_t err = OK;    int64_t maxDurationUs = 0;    int64_t minDurationUs = 0x7fffffffffffffffLL;    for (List<Track *>::iterator it = mTracks.begin();         it != mTracks.end(); ++it) {        status_t status = (*it)->stop();//停止轨迹线程        if (err == OK && status != OK) {            err = status;        }        int64_t durationUs = (*it)->getDurationUs();        if (durationUs > maxDurationUs) {            maxDurationUs = durationUs;        }        if (durationUs < minDurationUs) {            minDurationUs = durationUs;        }    }    if (mTracks.size() > 1) {        ALOGD("Duration from tracks range is [%lld, %lld] us",            minDurationUs, maxDurationUs);    }     <span style="background-color: rgb(51, 255, 255);">   stopWriterThread();</span><span style="color:#ff0000;"> //停止封装文件的写线程</span>	    // Do not write out movie header on error.    if (err != OK) {        release();        return err;    }    // Fix up the size of the 'mdat' chunk.    if (mUse32BitOffset) {        lseek64(mFd, mMdatOffset, SEEK_SET);        uint32_t size = htonl(static_cast<uint32_t>(mOffset - mMdatOffset));        ::write(mFd, &size, 4);    } else {        lseek64(mFd, mMdatOffset + 8, SEEK_SET);        uint64_t size = mOffset - mMdatOffset;        size = hton64(size);        ::write(mFd, &size, 8);    }    lseek64(mFd, mOffset, SEEK_SET);    // Construct moov box now    mMoovBoxBufferOffset = 0;    mWriteMoovBoxToMemory = mStreamableFile;    if (mWriteMoovBoxToMemory) {        // There is no need to allocate in-memory cache        // for moov box if the file is not streamable.        mMoovBoxBuffer = (uint8_t *) malloc(mEstimatedMoovBoxSize);        CHECK(mMoovBoxBuffer != NULL);    }   <span style="background-color: rgb(51, 255, 255);"> writeMoovBox(maxDurationUs)</span>;<span style="color:#ff0000;">//封装文件尾部相应信息的写入</span>    // mWriteMoovBoxToMemory could be set to false in    // MPEG4Writer::write() method    if (mWriteMoovBoxToMemory) {        mWriteMoovBoxToMemory = false;        // Content of the moov box is saved in the cache, and the in-memory        // moov box needs to be written to the file in a single shot.        CHECK_LE(mMoovBoxBufferOffset + 8, mEstimatedMoovBoxSize);        // Moov box        lseek64(mFd, mFreeBoxOffset, SEEK_SET);        mOffset = mFreeBoxOffset;        write(mMoovBoxBuffer, 1, mMoovBoxBufferOffset);        // Free box        lseek64(mFd, mOffset, SEEK_SET);        writeInt32(mEstimatedMoovBoxSize - mMoovBoxBufferOffset);        write("free", 4);    } else {        ALOGI("The mp4 file will not be streamable.");    }    // Free in-memory cache for moov box    if (mMoovBoxBuffer != NULL) {        free(mMoovBoxBuffer);        mMoovBoxBuffer = NULL;        mMoovBoxBufferOffset = 0;    }    CHECK(mBoxes.empty());    release();    return err;}

  release()中关闭文件描述符

void MPEG4Writer::release() {	ALOGD("***** release()!!!");   <span style="background-color: rgb(51, 255, 255);"> close(mFd);</span>    mFd = -1;    mInitCheck = NO_INIT;    mStarted = false;}
    至此,整个录制文件的封装过程,大体流程走完,就是有轨迹线程不停的读取数据,然后读取的数据达到一定的大小时,也就是成chunk(块)时,将会通知写入线程去检测是否有chunk可写,有的话,将进行数据的写入操作。整个封装文件必须有相应的头部信息和尾部信息。

  由于能力有限,只是进行了简单的跟读,对整个流程有大体的了解。其中不免有说错的地方,还望指教。











版权声明:本文为博主原创文章,未经博主允许不得转载。

  相关解决方案