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

Commit ff0508b3 authored by Marco Nelissen's avatar Marco Nelissen
Browse files

Convert MPEG2 extractor to V3 format 

and move it to the media APEX.

Bug: 111407253
Test: manual, CTS
Change-Id: Ibcbdd0e901e9d79b5a857b5d0a65bd6b1ec675a6
parent 48d4fff7

apex/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ apex { 
        "libmkvextractor",

        "libmp3extractor",

        "libmp4extractor",

        "libmpeg2extractor",

        "liboggextractor",

        "libwavextractor",

    ],

media/extractors/mpeg2/Android.bp

+6 −4
Original line number Diff line number Diff line
@@ -17,12 +17,9 @@ cc_library_shared { 
        "android.hidl.token@1.0-utils",

        "android.hidl.allocator@1.0",

        "libhidlmemory",

        "libcrypto",

        "libcutils",

        "libhidlbase",

        "liblog",

        "libmediaextractor",

        "libstagefright_foundation",

        "libmediandk",

    ],



    header_libs: [
@@ -30,8 +27,13 @@ cc_library_shared { 
    ],



    static_libs: [

        "libcrypto",

        "libstagefright_foundation",

        "libstagefright_mpeg2support",

        "libmediaextractor",

        "libutils",

        "libstagefright",

        "libstagefright_esds",

    ],



    name: "libmpeg2extractor",

media/extractors/mpeg2/ExtractorBundle.cpp

+7 −7
Original line number Diff line number Diff line
@@ -31,27 +31,27 @@ extern "C" { 
__attribute__ ((visibility ("default")))

ExtractorDef GETEXTRACTORDEF() {

    return {

        EXTRACTORDEF_VERSION,

        EXTRACTORDEF_VERSION_CURRENT + 1,

        UUID("3d1dcfeb-e40a-436d-a574-c2438a555e5f"),

        1,

        "MPEG2-PS/TS Extractor",

        {

            [](

            .v3 = [](

                    CDataSource *source,

                    float *confidence,

                    void **,

                    FreeMetaFunc *) -> CreatorFunc {

                    FreeMetaFunc *) -> CreatorFuncV3 {

                DataSourceHelper helper(source);

                if (SniffMPEG2TS(&helper, confidence)) {

                    return [](

                            CDataSource *source,

                            void *) -> CMediaExtractor* {

                        return wrap(new MPEG2TSExtractor(new DataSourceHelper(source)));};

                            void *) -> CMediaExtractorV3* {

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

                } else if (SniffMPEG2PS(&helper, confidence)) {

                            return [](

                                    CDataSource *source,

                                    void *) -> CMediaExtractor* {

                                return wrap(new MPEG2PSExtractor(new DataSourceHelper(source)));};

                                    void *) -> CMediaExtractorV3* {

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

                }

                return NULL;

            }

media/extractors/mpeg2/MPEG2PSExtractor.cpp

+98 −44
Original line number Diff line number Diff line
@@ -33,22 +33,23 @@ 
#include <media/stagefright/MediaDefs.h>

#include <media/stagefright/MediaErrors.h>

#include <media/stagefright/MetaData.h>

#include <media/stagefright/Utils.h>

#include <utils/String8.h>



#include <inttypes.h>



namespace android {



struct MPEG2PSExtractor::Track : public MediaTrackHelper, public RefBase {

struct MPEG2PSExtractor::Track : public MediaTrackHelperV3 {

    Track(MPEG2PSExtractor *extractor,

          unsigned stream_id, unsigned stream_type);



    virtual status_t start();

    virtual status_t stop();

    virtual status_t getFormat(MetaDataBase &);

    virtual media_status_t start();

    virtual media_status_t stop();

    virtual media_status_t getFormat(AMediaFormat *);



    virtual status_t read(

            MediaBufferBase **buffer, const ReadOptions *options);

    virtual media_status_t read(

            MediaBufferHelperV3 **buffer, const ReadOptions *options);



protected:

    virtual ~Track();
@@ -71,22 +72,22 @@ private: 
    DISALLOW_EVIL_CONSTRUCTORS(Track);

};



struct MPEG2PSExtractor::WrappedTrack : public MediaTrackHelper {

    WrappedTrack(MPEG2PSExtractor *extractor, const sp<Track> &track);

struct MPEG2PSExtractor::WrappedTrack : public MediaTrackHelperV3 {

    WrappedTrack(MPEG2PSExtractor *extractor, Track *track);



    virtual status_t start();

    virtual status_t stop();

    virtual status_t getFormat(MetaDataBase &);

    virtual media_status_t start();

    virtual media_status_t stop();

    virtual media_status_t getFormat(AMediaFormat *);



    virtual status_t read(

            MediaBufferBase **buffer, const ReadOptions *options);

    virtual media_status_t read(

            MediaBufferHelperV3 **buffer, const ReadOptions *options);



protected:

    virtual ~WrappedTrack();



private:

    MPEG2PSExtractor *mExtractor;

    sp<MPEG2PSExtractor::Track> mTrack;

    MPEG2PSExtractor::Track *mTrack;



    DISALLOW_EVIL_CONSTRUCTORS(WrappedTrack);

};
@@ -107,13 +108,14 @@ MPEG2PSExtractor::MPEG2PSExtractor(DataSourceHelper *source) 
    }



    // Remove all tracks that were unable to determine their format.

    MetaDataBase meta;

    AMediaFormat *meta = AMediaFormat_new();

    for (size_t i = mTracks.size(); i > 0;) {

        i--;

        if (mTracks.valueAt(i)->getFormat(meta) != OK) {

        if (mTracks.valueAt(i)->getFormat(meta) != AMEDIA_OK) {

            mTracks.removeItemsAt(i);

        }

    }

    AMediaFormat_delete(meta);



    mScanning = false;

}
@@ -126,7 +128,7 @@ size_t MPEG2PSExtractor::countTracks() { 
    return mTracks.size();

}



MediaTrackHelper *MPEG2PSExtractor::getTrack(size_t index) {

MediaTrackHelperV3 *MPEG2PSExtractor::getTrack(size_t index) {

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

        return NULL;

    }
@@ -134,20 +136,20 @@ MediaTrackHelper *MPEG2PSExtractor::getTrack(size_t index) { 
    return new WrappedTrack(this, mTracks.valueAt(index));

}



status_t MPEG2PSExtractor::getTrackMetaData(

        MetaDataBase &meta,

media_status_t MPEG2PSExtractor::getTrackMetaData(

        AMediaFormat *meta,

        size_t index, uint32_t /* flags */) {

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

        return UNKNOWN_ERROR;

        return AMEDIA_ERROR_UNKNOWN;

    }



    return mTracks.valueAt(index)->getFormat(meta);

}



status_t MPEG2PSExtractor::getMetaData(MetaDataBase &meta) {

    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_CONTAINER_MPEG2PS);

media_status_t MPEG2PSExtractor::getMetaData(AMediaFormat *meta) {

    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_CONTAINER_MPEG2PS);



    return OK;

    return AMEDIA_OK;

}



uint32_t MPEG2PSExtractor::flags() const {
@@ -635,42 +637,55 @@ MPEG2PSExtractor::Track::~Track() { 
    mQueue = NULL;

}



status_t MPEG2PSExtractor::Track::start() {

media_status_t MPEG2PSExtractor::Track::start() {

    if (mSource == NULL) {

        return NO_INIT;

        return AMEDIA_ERROR_UNKNOWN;

    }



    return mSource->start(NULL); // AnotherPacketSource::start doesn't use its argument

    // initialize with one small buffer, but allow growth

    mBufferGroup->init(1 /* one buffer */, 256 /* buffer size */, 64 /* max number of buffers */);



    if (mSource->start(NULL) == OK) { // AnotherPacketSource::start doesn't use its argument

        return AMEDIA_OK;

    }

    return AMEDIA_ERROR_UNKNOWN;

}



status_t MPEG2PSExtractor::Track::stop() {

media_status_t MPEG2PSExtractor::Track::stop() {

    if (mSource == NULL) {

        return NO_INIT;

        return AMEDIA_ERROR_UNKNOWN;

    }



    return mSource->stop();

    if (mSource->stop() == OK) {

        return AMEDIA_OK;

    }

    return AMEDIA_ERROR_UNKNOWN;

}



status_t MPEG2PSExtractor::Track::getFormat(MetaDataBase &meta) {

void copyAMessageToAMediaFormat(AMediaFormat *format, sp<AMessage> msg);



media_status_t MPEG2PSExtractor::Track::getFormat(AMediaFormat *meta) {

    if (mSource == NULL) {

        return NO_INIT;

        return AMEDIA_ERROR_UNKNOWN;

    }



    sp<MetaData> sourceMeta = mSource->getFormat();

    meta = *sourceMeta;

    return OK;

    sp<AMessage> msg;

    convertMetaDataToMessage(sourceMeta, &msg);

    copyAMessageToAMediaFormat(meta, msg);

    return AMEDIA_OK;

}



status_t MPEG2PSExtractor::Track::read(

        MediaBufferBase **buffer, const ReadOptions *options) {

media_status_t MPEG2PSExtractor::Track::read(

        MediaBufferHelperV3 **buffer, const ReadOptions *options) {

    if (mSource == NULL) {

        return NO_INIT;

        return AMEDIA_ERROR_UNKNOWN;

    }



    status_t finalResult;

    while (!mSource->hasBufferAvailable(&finalResult)) {

        if (finalResult != OK) {

            return ERROR_END_OF_STREAM;

            return AMEDIA_ERROR_END_OF_STREAM;

        }



        status_t err = mExtractor->feedMore();
@@ -680,7 +695,46 @@ status_t MPEG2PSExtractor::Track::read( 
        }

    }



    return mSource->read(buffer, (MediaSource::ReadOptions*)options);

    MediaBufferBase *mbuf;

    mSource->read(&mbuf, (MediaTrack::ReadOptions*) options);

    size_t length = mbuf->range_length();

    MediaBufferHelperV3 *outbuf;

    mBufferGroup->acquire_buffer(&outbuf, false, length);

    memcpy(outbuf->data(), mbuf->data(), length);

    outbuf->set_range(0, length);

    *buffer = outbuf;

    MetaDataBase &inMeta = mbuf->meta_data();

    AMediaFormat *outMeta = outbuf->meta_data();

    int64_t val64;

    if (inMeta.findInt64(kKeyTime, &val64)) {

        AMediaFormat_setInt64(outMeta, AMEDIAFORMAT_KEY_TIME_US, val64);

    }

    int32_t val32;

    if (inMeta.findInt32(kKeyIsSyncFrame, &val32)) {

        AMediaFormat_setInt32(outMeta, AMEDIAFORMAT_KEY_IS_SYNC_FRAME, val32);

    }

    if (inMeta.findInt32(kKeyCryptoMode, &val32)) {

        AMediaFormat_setInt32(outMeta, AMEDIAFORMAT_KEY_CRYPTO_MODE, val32);

    }

    uint32_t bufType;

    const void *bufData;

    size_t bufSize;

    if (inMeta.findData(kKeyCryptoIV, &bufType, &bufData, &bufSize)) {

        AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_IV, bufData, bufSize);

    }

    if (inMeta.findData(kKeyCryptoKey, &bufType, &bufData, &bufSize)) {

        AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_KEY, bufData, bufSize);

    }

    if (inMeta.findData(kKeyPlainSizes, &bufType, &bufData, &bufSize)) {

        AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES, bufData, bufSize);

    }

    if (inMeta.findData(kKeyEncryptedSizes, &bufType, &bufData, &bufSize)) {

        AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES, bufData, bufSize);

    }

    if (inMeta.findData(kKeySEI, &bufType, &bufData, &bufSize)) {

        AMediaFormat_setBuffer(outMeta, AMEDIAFORMAT_KEY_SEI, bufData, bufSize);

    }

    return AMEDIA_OK;

}



status_t MPEG2PSExtractor::Track::appendPESData(
@@ -726,7 +780,7 @@ status_t MPEG2PSExtractor::Track::appendPESData( 
////////////////////////////////////////////////////////////////////////////////



MPEG2PSExtractor::WrappedTrack::WrappedTrack(

        MPEG2PSExtractor *extractor, const sp<Track> &track)

        MPEG2PSExtractor *extractor, Track *track)

    : mExtractor(extractor),

      mTrack(track) {

}
@@ -734,20 +788,20 @@ MPEG2PSExtractor::WrappedTrack::WrappedTrack( 
MPEG2PSExtractor::WrappedTrack::~WrappedTrack() {

}



status_t MPEG2PSExtractor::WrappedTrack::start() {

media_status_t MPEG2PSExtractor::WrappedTrack::start() {

    return mTrack->start();

}



status_t MPEG2PSExtractor::WrappedTrack::stop() {

media_status_t MPEG2PSExtractor::WrappedTrack::stop() {

    return mTrack->stop();

}



status_t MPEG2PSExtractor::WrappedTrack::getFormat(MetaDataBase &meta) {

media_status_t MPEG2PSExtractor::WrappedTrack::getFormat(AMediaFormat *meta) {

    return mTrack->getFormat(meta);

}



status_t MPEG2PSExtractor::WrappedTrack::read(

        MediaBufferBase **buffer, const ReadOptions *options) {

media_status_t MPEG2PSExtractor::WrappedTrack::read(

        MediaBufferHelperV3 **buffer, const ReadOptions *options) {

    return mTrack->read(buffer, options);

}

media/extractors/mpeg2/MPEG2PSExtractor.h

+5 −5
Original line number Diff line number Diff line
@@ -32,14 +32,14 @@ struct AMessage; 
struct Track;

class String8;



struct MPEG2PSExtractor : public MediaExtractorPluginHelper {

struct MPEG2PSExtractor : public MediaExtractorPluginHelperV3 {

    explicit MPEG2PSExtractor(DataSourceHelper *source);



    virtual size_t countTracks();

    virtual MediaTrackHelper *getTrack(size_t index);

    virtual status_t getTrackMetaData(MetaDataBase& meta, size_t index, uint32_t flags);

    virtual MediaTrackHelperV3 *getTrack(size_t index);

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



    virtual status_t getMetaData(MetaDataBase& meta);

    virtual media_status_t getMetaData(AMediaFormat *meta);



    virtual uint32_t flags() const;

    virtual const char * name() { return "MPEG2PSExtractor"; }
@@ -57,7 +57,7 @@ private: 
    off64_t mOffset;

    status_t mFinalResult;

    sp<ABuffer> mBuffer;

    KeyedVector<unsigned, sp<Track> > mTracks;

    KeyedVector<unsigned, Track* > mTracks;

    bool mScanning;



    bool mProgramStreamMapValid;