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
Loading
Loading
Loading
Loading
+0 −1
Original line number Diff line number Diff line
@@ -11,7 +11,6 @@ cc_library_shared {

    shared_libs: [
        "liblog",
        "libmediaextractor",
        "libmediandk",
    ],

+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;
            }
+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);

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

    shared_libs: [
        "liblog",
        "libmediaextractor",
        "libmediandk"
    ],

+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 }
    };
}

Loading