Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2017e7af authored by Marco Nelissen's avatar Marco Nelissen Committed by Android (Google) Code Review
Browse files

Merge changes I16e1fa82,Ic59ebc1b 

* changes:
  Convert MatroskaExtractor to V3 format
  Convert MPEG4Extractor to V3 format
parents 980af763 1d1da3d5

media/extractors/mkv/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -11,7 +11,6 @@ cc_library_shared { 


    shared_libs: [

        "liblog",

        "libmediaextractor",

        "libmediandk",

    ],

media/extractors/mkv/MatroskaExtractor.cpp

+51 −38
Original line number Diff line number Diff line
@@ -29,10 +29,8 @@ 
#include <media/stagefright/foundation/ByteUtils.h>

#include <media/stagefright/foundation/ColorUtils.h>

#include <media/stagefright/foundation/hexdump.h>

#include <media/stagefright/MediaBufferBase.h>

#include <media/stagefright/MediaDefs.h>

#include <media/stagefright/MediaErrors.h>

#include <media/stagefright/MetaData.h>

#include <media/stagefright/MetaDataUtils.h>

#include <utils/String8.h>
@@ -127,7 +125,7 @@ private: 
    BlockIterator &operator=(const BlockIterator &);

};



struct MatroskaSource : public MediaTrackHelperV2 {

struct MatroskaSource : public MediaTrackHelperV3 {

    MatroskaSource(MatroskaExtractor *extractor, size_t index);



    virtual media_status_t start();
@@ -136,7 +134,7 @@ struct MatroskaSource : public MediaTrackHelperV2 { 
    virtual media_status_t getFormat(AMediaFormat *);



    virtual media_status_t read(

            MediaBufferBase **buffer, const ReadOptions *options);

            MediaBufferHelperV3 **buffer, const ReadOptions *options);



protected:

    virtual ~MatroskaSource();
@@ -156,11 +154,11 @@ private: 
    BlockIterator mBlockIter;

    ssize_t mNALSizeLen;  // for type AVC or HEVC



    List<MediaBufferBase *> mPendingFrames;

    List<MediaBufferHelperV3 *> mPendingFrames;



    status_t advance();



    status_t setWebmBlockCryptoInfo(MediaBufferBase *mbuf);

    status_t setWebmBlockCryptoInfo(MediaBufferHelperV3 *mbuf);

    media_status_t readBlock();

    void clearPendingFrames();
@@ -265,6 +263,8 @@ media_status_t MatroskaSource::start() { 
        return AMEDIA_ERROR_MALFORMED;

    }



    // allocate one small initial buffer, but leave plenty of room to grow

    mBufferGroup->init(1 /* number of buffers */, 1024 /* buffer size */, 64 /* growth limit */);

    mBlockIter.reset();



    return AMEDIA_OK;
@@ -569,7 +569,7 @@ static AString uriDebugString(const char *uri) { 


void MatroskaSource::clearPendingFrames() {

    while (!mPendingFrames.empty()) {

        MediaBufferBase *frame = *mPendingFrames.begin();

        MediaBufferHelperV3 *frame = *mPendingFrames.begin();

        mPendingFrames.erase(mPendingFrames.begin());



        frame->release();
@@ -577,7 +577,7 @@ void MatroskaSource::clearPendingFrames() { 
    }

}



status_t MatroskaSource::setWebmBlockCryptoInfo(MediaBufferBase *mbuf) {

status_t MatroskaSource::setWebmBlockCryptoInfo(MediaBufferHelperV3 *mbuf) {

    if (mbuf->range_length() < 1 || mbuf->range_length() - 1 > INT32_MAX) {

        // 1-byte signal

        return ERROR_MALFORMED;
@@ -591,7 +591,7 @@ status_t MatroskaSource::setWebmBlockCryptoInfo(MediaBufferBase *mbuf) { 
        return ERROR_MALFORMED;

    }



    MetaDataBase &meta = mbuf->meta_data();

    AMediaFormat *meta = mbuf->meta_data();

    if (encrypted) {

        uint8_t ctrCounter[16] = { 0 };

        const uint8_t *keyId;
@@ -599,9 +599,9 @@ status_t MatroskaSource::setWebmBlockCryptoInfo(MediaBufferBase *mbuf) { 
        AMediaFormat *trackMeta = mExtractor->mTracks.itemAt(mTrackIndex).mMeta;

        AMediaFormat_getBuffer(trackMeta, AMEDIAFORMAT_KEY_CRYPTO_KEY,

                (void**)&keyId, &keyIdSize);

        meta.setData(kKeyCryptoKey, 0, keyId, keyIdSize);

        AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_KEY, keyId, keyIdSize);

        memcpy(ctrCounter, data + 1, 8);

        meta.setData(kKeyCryptoIV, 0, ctrCounter, 16);

        AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_IV, ctrCounter, 16);

        if (partitioned) {

            /*  0                   1                   2                   3

             *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -654,8 +654,10 @@ status_t MatroskaSource::setWebmBlockCryptoInfo(MediaBufferBase *mbuf) { 
            }

            uint32_t sizeofPlainSizes = sizeof(uint32_t) * plainSizes.size();

            uint32_t sizeofEncryptedSizes = sizeof(uint32_t) * encryptedSizes.size();

            meta.setData(kKeyPlainSizes, 0, plainSizes.data(), sizeofPlainSizes);

            meta.setData(kKeyEncryptedSizes, 0, encryptedSizes.data(), sizeofEncryptedSizes);

            AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES,

                    plainSizes.data(), sizeofPlainSizes);

            AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES,

                    encryptedSizes.data(), sizeofEncryptedSizes);

            mbuf->set_range(frameOffset, mbuf->range_length() - frameOffset);

        } else {

            /*
@@ -675,8 +677,10 @@ status_t MatroskaSource::setWebmBlockCryptoInfo(MediaBufferBase *mbuf) { 
             */

            int32_t plainSizes[] = { 0 };

            int32_t encryptedSizes[] = { static_cast<int32_t>(mbuf->range_length() - 9) };

            meta.setData(kKeyPlainSizes, 0, plainSizes, sizeof(plainSizes));

            meta.setData(kKeyEncryptedSizes, 0, encryptedSizes, sizeof(encryptedSizes));

            AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES,

                    plainSizes, sizeof(plainSizes));

            AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES,

                    encryptedSizes, sizeof(encryptedSizes));

            mbuf->set_range(9, mbuf->range_length() - 9);

        }

    } else {
@@ -693,8 +697,10 @@ status_t MatroskaSource::setWebmBlockCryptoInfo(MediaBufferBase *mbuf) { 
         */

        int32_t plainSizes[] = { static_cast<int32_t>(mbuf->range_length() - 1) };

        int32_t encryptedSizes[] = { 0 };

        meta.setData(kKeyPlainSizes, 0, plainSizes, sizeof(plainSizes));

        meta.setData(kKeyEncryptedSizes, 0, encryptedSizes, sizeof(encryptedSizes));

        AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES,

                plainSizes, sizeof(plainSizes));

        AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES,

                encryptedSizes, sizeof(encryptedSizes));

        mbuf->set_range(1, mbuf->range_length() - 1);

    }
@@ -721,14 +727,17 @@ media_status_t MatroskaSource::readBlock() { 
        }



        len += trackInfo->mHeaderLen;

        MediaBufferBase *mbuf = MediaBufferBase::Create(len);

        MediaBufferHelperV3 *mbuf;

        mBufferGroup->acquire_buffer(&mbuf, false /* nonblocking */, len /* requested size */);

        mbuf->set_range(0, len);

        uint8_t *data = static_cast<uint8_t *>(mbuf->data());

        if (trackInfo->mHeader) {

            memcpy(data, trackInfo->mHeader, trackInfo->mHeaderLen);

        }



        mbuf->meta_data().setInt64(kKeyTime, timeUs);

        mbuf->meta_data().setInt32(kKeyIsSyncFrame, block->IsKey());

        AMediaFormat *meta = mbuf->meta_data();

        AMediaFormat_setInt64(meta, AMEDIAFORMAT_KEY_TIME_US, timeUs);

        AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, block->IsKey());



        status_t err = frame.Read(mExtractor->mReader, data + trackInfo->mHeaderLen);

        if (err == OK
@@ -754,7 +763,7 @@ media_status_t MatroskaSource::readBlock() { 
}



media_status_t MatroskaSource::read(

        MediaBufferBase **out, const ReadOptions *options) {

        MediaBufferHelperV3 **out, const ReadOptions *options) {

    *out = NULL;



    int64_t targetSampleTimeUs = -1ll;
@@ -790,13 +799,13 @@ media_status_t MatroskaSource::read( 
        }

    }



    MediaBufferBase *frame = *mPendingFrames.begin();

    MediaBufferHelperV3 *frame = *mPendingFrames.begin();

    mPendingFrames.erase(mPendingFrames.begin());



    if ((mType != AVC && mType != HEVC) || mNALSizeLen == 0) {

        if (targetSampleTimeUs >= 0ll) {

            frame->meta_data().setInt64(

                    kKeyTargetTime, targetSampleTimeUs);

            AMediaFormat_setInt64(frame->meta_data(),

                    AMEDIAFORMAT_KEY_TARGET_TIME, targetSampleTimeUs);

        }



        *out = frame;
@@ -819,7 +828,7 @@ media_status_t MatroskaSource::read( 
    size_t srcSize = frame->range_length();



    size_t dstSize = 0;

    MediaBufferBase *buffer = NULL;

    MediaBufferHelperV3 *buffer = NULL;

    uint8_t *dstPtr = NULL;



    for (int32_t pass = 0; pass < 2; ++pass) {
@@ -879,16 +888,20 @@ media_status_t MatroskaSource::read( 
                // each 4-byte nal size with a 4-byte start code

                buffer = frame;

            } else {

                buffer = MediaBufferBase::Create(dstSize);

                mBufferGroup->acquire_buffer(

                        &buffer, false /* nonblocking */, dstSize /* requested size */);

                buffer->set_range(0, dstSize);

            }



            AMediaFormat *frameMeta = frame->meta_data();

            int64_t timeUs;

            CHECK(frame->meta_data().findInt64(kKeyTime, &timeUs));

            CHECK(AMediaFormat_getInt64(frameMeta, AMEDIAFORMAT_KEY_TIME_US, &timeUs));

            int32_t isSync;

            CHECK(frame->meta_data().findInt32(kKeyIsSyncFrame, &isSync));

            CHECK(AMediaFormat_getInt32(frameMeta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, &isSync));



            buffer->meta_data().setInt64(kKeyTime, timeUs);

            buffer->meta_data().setInt32(kKeyIsSyncFrame, isSync);

            AMediaFormat *bufMeta = buffer->meta_data();

            AMediaFormat_setInt64(bufMeta, AMEDIAFORMAT_KEY_TIME_US, timeUs);

            AMediaFormat_setInt32(bufMeta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, isSync);



            dstPtr = (uint8_t *)buffer->data();

        }
@@ -900,8 +913,8 @@ media_status_t MatroskaSource::read( 
    }



    if (targetSampleTimeUs >= 0ll) {

        buffer->meta_data().setInt64(

                kKeyTargetTime, targetSampleTimeUs);

        AMediaFormat_setInt64(buffer->meta_data(),

                AMEDIAFORMAT_KEY_TARGET_TIME, targetSampleTimeUs);

    }



    *out = buffer;
@@ -992,7 +1005,7 @@ size_t MatroskaExtractor::countTracks() { 
    return mTracks.size();

}



MediaTrackHelperV2 *MatroskaExtractor::getTrack(size_t index) {

MediaTrackHelperV3 *MatroskaExtractor::getTrack(size_t index) {

    if (index >= mTracks.size()) {

        return NULL;

    }
@@ -1660,22 +1673,22 @@ extern "C" { 
__attribute__ ((visibility ("default")))

ExtractorDef GETEXTRACTORDEF() {

    return {

        EXTRACTORDEF_VERSION_CURRENT,

        EXTRACTORDEF_VERSION_CURRENT + 1,

        UUID("abbedd92-38c4-4904-a4c1-b3f45f899980"),

        1,

        "Matroska Extractor",

        {

            .v2 = [](

            .v3 = [](

                    CDataSource *source,

                    float *confidence,

                    void **,

                    FreeMetaFunc *) -> CreatorFuncV2 {

                    FreeMetaFunc *) -> CreatorFuncV3 {

                DataSourceHelper helper(source);

                if (SniffMatroska(&helper, confidence)) {

                    return [](

                            CDataSource *source,

                            void *) -> CMediaExtractorV2* {

                        return wrapV2(new MatroskaExtractor(new DataSourceHelper(source)));};

                            void *) -> CMediaExtractorV3* {

                        return wrapV3(new MatroskaExtractor(new DataSourceHelper(source)));};

                }

                return NULL;

            }

media/extractors/mkv/MatroskaExtractor.h

+2 −2
Original line number Diff line number Diff line
@@ -35,12 +35,12 @@ class MetaData; 
struct DataSourceBaseReader;

struct MatroskaSource;



struct MatroskaExtractor : public MediaExtractorPluginHelperV2 {

struct MatroskaExtractor : public MediaExtractorPluginHelperV3 {

    explicit MatroskaExtractor(DataSourceHelper *source);



    virtual size_t countTracks();



    virtual MediaTrackHelperV2 *getTrack(size_t index);

    virtual MediaTrackHelperV3 *getTrack(size_t index);



    virtual media_status_t getTrackMetaData(AMediaFormat *meta, size_t index, uint32_t flags);

media/extractors/mp4/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -15,7 +15,6 @@ cc_defaults { 


    shared_libs: [

        "liblog",

        "libmediaextractor",

        "libmediandk"

    ],

media/extractors/mp4/MPEG4Extractor.cpp

+78 −82
Original line number Diff line number Diff line
@@ -44,10 +44,9 @@ 
#include <media/stagefright/foundation/ColorUtils.h>

#include <media/stagefright/foundation/avc_utils.h>

#include <media/stagefright/foundation/hexdump.h>

#include <media/stagefright/MediaBufferBase.h>

#include <media/stagefright/MediaBufferGroup.h>

#include <media/stagefright/MediaDefs.h>

#include <media/stagefright/MetaData.h>

#include <media/stagefright/MetaDataBase.h>

#include <utils/String8.h>



#include <byteswap.h>
@@ -70,7 +69,7 @@ enum { 
    kMaxAtomSize = 64 * 1024 * 1024,

};



class MPEG4Source : public MediaTrackHelperV2 {

class MPEG4Source : public MediaTrackHelperV3 {

static const size_t  kMaxPcmFrameSize = 8192;

public:

    // Caller retains ownership of both "dataSource" and "sampleTable".
@@ -89,10 +88,10 @@ public: 


    virtual media_status_t getFormat(AMediaFormat *);



    virtual media_status_t read(MediaBufferBase **buffer, const ReadOptions *options = NULL);

    virtual media_status_t read(MediaBufferHelperV3 **buffer, const ReadOptions *options = NULL);

    virtual bool supportNonblockingRead() { return true; }

    virtual media_status_t fragmentedRead(

            MediaBufferBase **buffer, const ReadOptions *options = NULL);

            MediaBufferHelperV3 **buffer, const ReadOptions *options = NULL);



    virtual ~MPEG4Source();
@@ -137,9 +136,7 @@ private: 


    bool mStarted;



    MediaBufferGroup *mGroup;



    MediaBufferBase *mBuffer;

    MediaBufferHelperV3 *mBuffer;



    uint8_t *mSrcBuffer;
@@ -3827,7 +3824,7 @@ void MPEG4Extractor::parseID3v2MetaData(off64_t offset) { 
    }

}



MediaTrackHelperV2 *MPEG4Extractor::getTrack(size_t index) {

MediaTrackHelperV3 *MPEG4Extractor::getTrack(size_t index) {

    status_t err;

    if ((err = readMetaData()) != OK) {

        return NULL;
@@ -4329,7 +4326,6 @@ MPEG4Source::MPEG4Source( 
      mIsPcm(false),

      mNALLengthSize(0),

      mStarted(false),

      mGroup(NULL),

      mBuffer(NULL),

      mSrcBuffer(NULL),

      mIsHeif(itemTable != NULL),
@@ -4458,12 +4454,10 @@ media_status_t MPEG4Source::start() { 
    const size_t kInitialBuffers = 2;

    const size_t kMaxBuffers = 8;

    const size_t realMaxBuffers = min(kMaxBufferSize / max_size, kMaxBuffers);

    mGroup = new MediaBufferGroup(kInitialBuffers, max_size, realMaxBuffers);

    mBufferGroup->init(kInitialBuffers, max_size, realMaxBuffers);

    mSrcBuffer = new (std::nothrow) uint8_t[max_size];

    if (mSrcBuffer == NULL) {

        // file probably specified a bad max size

        delete mGroup;

        mGroup = NULL;

        return AMEDIA_ERROR_MALFORMED;

    }
@@ -4485,9 +4479,6 @@ media_status_t MPEG4Source::stop() { 
    delete[] mSrcBuffer;

    mSrcBuffer = NULL;



    delete mGroup;

    mGroup = NULL;



    mStarted = false;

    mCurrentSampleIndex = 0;
@@ -5184,12 +5175,12 @@ int32_t MPEG4Source::parseHEVCLayerId(const uint8_t *data, size_t size) { 
}



media_status_t MPEG4Source::read(

        MediaBufferBase **out, const ReadOptions *options) {

        MediaBufferHelperV3 **out, const ReadOptions *options) {

    Mutex::Autolock autoLock(mLock);



    CHECK(mStarted);



    if (options != nullptr && options->getNonBlocking() && !mGroup->has_buffers()) {

    if (options != nullptr && options->getNonBlocking() && !mBufferGroup->has_buffers()) {

        *out = nullptr;

        return AMEDIA_ERROR_WOULD_BLOCK;

    }
@@ -5338,7 +5329,7 @@ media_status_t MPEG4Source::read( 
            return AMEDIA_ERROR_UNKNOWN;

        }



        err = mGroup->acquire_buffer(&mBuffer);

        err = mBufferGroup->acquire_buffer(&mBuffer);



        if (err != OK) {

            CHECK(mBuffer == NULL);
@@ -5377,9 +5368,11 @@ media_status_t MPEG4Source::read( 
                    return AMEDIA_ERROR_IO;

                }



                mBuffer->meta_data().clear();

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

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

                AMediaFormat *meta = mBuffer->meta_data();

                AMediaFormat_clear(meta);

                AMediaFormat_setInt64(

                      meta, AMEDIAFORMAT_KEY_TIME_US, ((int64_t)cts * 1000000) / mTimescale);

                AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, 1);



                int32_t byteOrder;

                AMediaFormat_getInt32(mFormat,
@@ -5410,19 +5403,20 @@ media_status_t MPEG4Source::read( 


                CHECK(mBuffer != NULL);

                mBuffer->set_range(0, size);

                mBuffer->meta_data().clear();

                mBuffer->meta_data().setInt64(

                        kKeyTime, ((int64_t)cts * 1000000) / mTimescale);

                mBuffer->meta_data().setInt64(

                        kKeyDuration, ((int64_t)stts * 1000000) / mTimescale);

                AMediaFormat *meta = mBuffer->meta_data();

                AMediaFormat_clear(meta);

                AMediaFormat_setInt64(

                        meta, AMEDIAFORMAT_KEY_TIME_US, ((int64_t)cts * 1000000) / mTimescale);

                AMediaFormat_setInt64(

                        meta, AMEDIAFORMAT_KEY_DURATION, ((int64_t)stts * 1000000) / mTimescale);



                if (targetSampleTimeUs >= 0) {

                    mBuffer->meta_data().setInt64(

                            kKeyTargetTime, targetSampleTimeUs);

                    AMediaFormat_setInt64(

                            meta, AMEDIAFORMAT_KEY_TARGET_TIME, targetSampleTimeUs);

                }



                if (isSyncSample) {

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

                    AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, 1);

                }

 

                ++mCurrentSampleIndex;
@@ -5465,19 +5459,20 @@ media_status_t MPEG4Source::read( 
        }



        mBuffer->set_range(0, dstOffset + size);

        mBuffer->meta_data().clear();

        mBuffer->meta_data().setInt64(

                kKeyTime, ((int64_t)cts * 1000000) / mTimescale);

        mBuffer->meta_data().setInt64(

                kKeyDuration, ((int64_t)stts * 1000000) / mTimescale);

        AMediaFormat *meta = mBuffer->meta_data();

        AMediaFormat_clear(meta);

        AMediaFormat_setInt64(

                meta, AMEDIAFORMAT_KEY_TIME_US, ((int64_t)cts * 1000000) / mTimescale);

        AMediaFormat_setInt64(

                meta, AMEDIAFORMAT_KEY_DURATION, ((int64_t)stts * 1000000) / mTimescale);



        if (targetSampleTimeUs >= 0) {

            mBuffer->meta_data().setInt64(

                    kKeyTargetTime, targetSampleTimeUs);

            AMediaFormat_setInt64(

                    meta, AMEDIAFORMAT_KEY_TARGET_TIME, targetSampleTimeUs);

        }



        if (isSyncSample) {

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

            AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, 1);

        }



        ++mCurrentSampleIndex;
@@ -5545,31 +5540,32 @@ media_status_t MPEG4Source::read( 
        CHECK(mBuffer != NULL);

        mBuffer->set_range(0, dstOffset);



        mBuffer->meta_data().clear();

        mBuffer->meta_data().setInt64(

                kKeyTime, ((int64_t)cts * 1000000) / mTimescale);

        mBuffer->meta_data().setInt64(

                kKeyDuration, ((int64_t)stts * 1000000) / mTimescale);

        AMediaFormat *meta = mBuffer->meta_data();

        AMediaFormat_clear(meta);

        AMediaFormat_setInt64(

                meta, AMEDIAFORMAT_KEY_TIME_US, ((int64_t)cts * 1000000) / mTimescale);

        AMediaFormat_setInt64(

                meta, AMEDIAFORMAT_KEY_DURATION, ((int64_t)stts * 1000000) / mTimescale);



        if (targetSampleTimeUs >= 0) {

            mBuffer->meta_data().setInt64(

                    kKeyTargetTime, targetSampleTimeUs);

            AMediaFormat_setInt64(

                    meta, AMEDIAFORMAT_KEY_TARGET_TIME, targetSampleTimeUs);

        }



        if (mIsAVC) {

            uint32_t layerId = FindAVCLayerId(

                    (const uint8_t *)mBuffer->data(), mBuffer->range_length());

            mBuffer->meta_data().setInt32(kKeyTemporalLayerId, layerId);

            AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID, layerId);

        } else if (mIsHEVC) {

            int32_t layerId = parseHEVCLayerId(

                    (const uint8_t *)mBuffer->data(), mBuffer->range_length());

            if (layerId >= 0) {

                mBuffer->meta_data().setInt32(kKeyTemporalLayerId, layerId);

                AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID, layerId);

            }

        }



        if (isSyncSample) {

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

            AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, 1);

        }



        ++mCurrentSampleIndex;
@@ -5582,7 +5578,7 @@ media_status_t MPEG4Source::read( 
}



media_status_t MPEG4Source::fragmentedRead(

        MediaBufferBase **out, const ReadOptions *options) {

        MediaBufferHelperV3 **out, const ReadOptions *options) {



    ALOGV("MPEG4Source::fragmentedRead");
@@ -5685,7 +5681,7 @@ media_status_t MPEG4Source::fragmentedRead( 
        mCurrentTime += smpl->duration;

        isSyncSample = (mCurrentSampleIndex == 0);



        status_t err = mGroup->acquire_buffer(&mBuffer);

        status_t err = mBufferGroup->acquire_buffer(&mBuffer);



        if (err != OK) {

            CHECK(mBuffer == NULL);
@@ -5701,19 +5697,21 @@ media_status_t MPEG4Source::fragmentedRead( 
    }



    const Sample *smpl = &mCurrentSamples[mCurrentSampleIndex];

    MetaDataBase &bufmeta = mBuffer->meta_data();

    bufmeta.clear();

    AMediaFormat *bufmeta = mBuffer->meta_data();

    AMediaFormat_clear(bufmeta);

    if (smpl->encryptedsizes.size()) {

        // store clear/encrypted lengths in metadata

        bufmeta.setData(kKeyPlainSizes, 0,

        AMediaFormat_setBuffer(bufmeta, AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES,

                smpl->clearsizes.array(), smpl->clearsizes.size() * 4);

        bufmeta.setData(kKeyEncryptedSizes, 0,

        AMediaFormat_setBuffer(bufmeta, AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES,

                smpl->encryptedsizes.array(), smpl->encryptedsizes.size() * 4);

        bufmeta.setInt32(kKeyCryptoDefaultIVSize, mDefaultIVSize);

        bufmeta.setInt32(kKeyCryptoMode, mCryptoMode);

        bufmeta.setData(kKeyCryptoKey, 0, mCryptoKey, 16);

        bufmeta.setInt32(kKeyEncryptedByteBlock, mDefaultEncryptedByteBlock);

        bufmeta.setInt32(kKeySkipByteBlock, mDefaultSkipByteBlock);

        AMediaFormat_setInt32(bufmeta, AMEDIAFORMAT_KEY_CRYPTO_DEFAULT_IV_SIZE, mDefaultIVSize);

        AMediaFormat_setInt32(bufmeta, AMEDIAFORMAT_KEY_CRYPTO_MODE, mCryptoMode);

        AMediaFormat_setBuffer(bufmeta, AMEDIAFORMAT_KEY_CRYPTO_KEY, mCryptoKey, 16);

        AMediaFormat_setInt32(bufmeta,

                AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_BYTE_BLOCK, mDefaultEncryptedByteBlock);

        AMediaFormat_setInt32(bufmeta,

                AMEDIAFORMAT_KEY_CRYPTO_SKIP_BYTE_BLOCK, mDefaultSkipByteBlock);



        void *iv = NULL;

        size_t ivlength = 0;
@@ -5722,8 +5720,7 @@ media_status_t MPEG4Source::fragmentedRead( 
            iv = (void *) smpl->iv;

            ivlength = 16; // use 16 or the actual size?

        }

        bufmeta.setData(kKeyCryptoIV, 0, iv, ivlength);



        AMediaFormat_setBuffer(bufmeta, AMEDIAFORMAT_KEY_CRYPTO_IV, iv, ivlength);

    }



    if (!mIsAVC && !mIsHEVC) {
@@ -5749,30 +5746,29 @@ media_status_t MPEG4Source::fragmentedRead( 


            CHECK(mBuffer != NULL);

            mBuffer->set_range(0, size);

            mBuffer->meta_data().setInt64(

                    kKeyTime, ((int64_t)cts * 1000000) / mTimescale);

            mBuffer->meta_data().setInt64(

                    kKeyDuration, ((int64_t)smpl->duration * 1000000) / mTimescale);

            AMediaFormat_setInt64(bufmeta,

                    AMEDIAFORMAT_KEY_TIME_US, ((int64_t)cts * 1000000) / mTimescale);

            AMediaFormat_setInt64(bufmeta,

                    AMEDIAFORMAT_KEY_DURATION, ((int64_t)smpl->duration * 1000000) / mTimescale);



            if (targetSampleTimeUs >= 0) {

                mBuffer->meta_data().setInt64(

                        kKeyTargetTime, targetSampleTimeUs);

                AMediaFormat_setInt64(bufmeta, AMEDIAFORMAT_KEY_TARGET_TIME, targetSampleTimeUs);

            }



            if (mIsAVC) {

                uint32_t layerId = FindAVCLayerId(

                        (const uint8_t *)mBuffer->data(), mBuffer->range_length());

                mBuffer->meta_data().setInt32(kKeyTemporalLayerId, layerId);

                AMediaFormat_setInt32(bufmeta, AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID, layerId);

            } else if (mIsHEVC) {

                int32_t layerId = parseHEVCLayerId(

                        (const uint8_t *)mBuffer->data(), mBuffer->range_length());

                if (layerId >= 0) {

                    mBuffer->meta_data().setInt32(kKeyTemporalLayerId, layerId);

                    AMediaFormat_setInt32(bufmeta, AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID, layerId);

                }

            }



            if (isSyncSample) {

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

                AMediaFormat_setInt32(bufmeta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, 1);

            }



            ++mCurrentSampleIndex;
@@ -5864,18 +5860,18 @@ media_status_t MPEG4Source::fragmentedRead( 
        CHECK(mBuffer != NULL);

        mBuffer->set_range(0, dstOffset);



        mBuffer->meta_data().setInt64(

                kKeyTime, ((int64_t)cts * 1000000) / mTimescale);

        mBuffer->meta_data().setInt64(

                kKeyDuration, ((int64_t)smpl->duration * 1000000) / mTimescale);

        AMediaFormat *bufmeta = mBuffer->meta_data();

        AMediaFormat_setInt64(bufmeta,

                AMEDIAFORMAT_KEY_TIME_US, ((int64_t)cts * 1000000) / mTimescale);

        AMediaFormat_setInt64(bufmeta,

                AMEDIAFORMAT_KEY_DURATION, ((int64_t)smpl->duration * 1000000) / mTimescale);



        if (targetSampleTimeUs >= 0) {

            mBuffer->meta_data().setInt64(

                    kKeyTargetTime, targetSampleTimeUs);

            AMediaFormat_setInt64(bufmeta, AMEDIAFORMAT_KEY_TARGET_TIME, targetSampleTimeUs);

        }



        if (isSyncSample) {

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

            AMediaFormat_setInt32(bufmeta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, 1);

        }



        ++mCurrentSampleIndex;
@@ -6075,11 +6071,11 @@ static bool BetterSniffMPEG4(DataSourceHelper *source, float *confidence) { 
    return true;

}



static CMediaExtractorV2* CreateExtractor(CDataSource *source, void *) {

    return wrapV2(new MPEG4Extractor(new DataSourceHelper(source)));

static CMediaExtractorV3* CreateExtractor(CDataSource *source, void *) {

    return wrapV3(new MPEG4Extractor(new DataSourceHelper(source)));

}



static CreatorFuncV2 Sniff(

static CreatorFuncV3 Sniff(

        CDataSource *source, float *confidence, void **,

        FreeMetaFunc *) {

    DataSourceHelper helper(source);
@@ -6100,11 +6096,11 @@ extern "C" { 
__attribute__ ((visibility ("default")))

ExtractorDef GETEXTRACTORDEF() {

    return {

        EXTRACTORDEF_VERSION_CURRENT,

        EXTRACTORDEF_VERSION_CURRENT + 1,

        UUID("27575c67-4417-4c54-8d3d-8e626985a164"),

        2, // version

        "MP4 Extractor",

        { .v2 = Sniff }

        { .v3 = Sniff }

    };

}