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

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

Remove support for non-NDK extractor formats 

Remove support for intermediate extractor format versions
and leave only the 'V3' format, but remove 'V3' from the
names of the classes and structs involved, and reset the
version number back to 2 (version 1 is the C++ interface
shipped in P, which is no longer supported).

Bug: 111407253
Test: build
Change-Id: I702080e6bbfbac265967a93945ee97191d463125
parent 3c3c97ae

include/media/MediaExtractorPluginApi.h

+18 −85
Original line number Diff line number Diff line
@@ -47,33 +47,11 @@ enum CMediaTrackReadOptions : uint32_t { 
    NONBLOCKING = 16

};



struct CMediaTrack {

    void *data;

    void (*free)(void *data);



    status_t (*start)(void *data);

    status_t (*stop)(void *data);

    status_t (*getFormat)(void *data, MetaDataBase &format);

    status_t (*read)(void *data, MediaBufferBase **buffer, uint32_t options, int64_t seekPosUs);

    bool     (*supportsNonBlockingRead)(void *data);

};



struct CMediaTrackV2 {

    void *data;

    void (*free)(void *data);



    media_status_t (*start)(void *data);

    media_status_t (*stop)(void *data);

    media_status_t (*getFormat)(void *data, AMediaFormat *format);

    media_status_t (*read)(void *data, MediaBufferBase **buffer, uint32_t options, int64_t seekPosUs);

    bool     (*supportsNonBlockingRead)(void *data);

};



/**

 * only use CMediaBufferV3 allocated from the CMediaBufferGroupV3 that is

 * only use CMediaBuffer allocated from the CMediaBufferGroup that is

 * provided to CMediaTrack::start()

 */

struct CMediaBufferV3 {

struct CMediaBuffer {

    void *handle;

    void (*release)(void *handle);

    void* (*data)(void *handle);
@@ -84,49 +62,32 @@ struct CMediaBufferV3 { 
    AMediaFormat* (*meta_data)(void *handle);

};



struct CMediaBufferGroupV3 {

struct CMediaBufferGroup {

    void *handle;

    bool (*init)(void *handle, size_t buffers, size_t buffer_size, size_t growthLimit);

    void (*add_buffer)(void *handle, size_t size);

    media_status_t (*acquire_buffer)(void *handle,

            CMediaBufferV3 **buffer, bool nonBlocking, size_t requestedSize);

            CMediaBuffer **buffer, bool nonBlocking, size_t requestedSize);

    bool (*has_buffers)(void *handle);

};



struct CMediaTrackV3 {

struct CMediaTrack {

    void *data;

    void (*free)(void *data);



    media_status_t (*start)(void *data, CMediaBufferGroupV3 *bufferGroup);

    media_status_t (*start)(void *data, CMediaBufferGroup *bufferGroup);

    media_status_t (*stop)(void *data);

    media_status_t (*getFormat)(void *data, AMediaFormat *format);

    media_status_t (*read)(void *data, CMediaBufferV3 **buffer, uint32_t options, int64_t seekPosUs);

    media_status_t (*read)(void *data, CMediaBuffer **buffer, uint32_t options, int64_t seekPosUs);

    bool     (*supportsNonBlockingRead)(void *data);

};



struct CMediaExtractorV1 {

struct CMediaExtractor {

    void *data;



    void (*free)(void *data);

    size_t (*countTracks)(void *data);

    CMediaTrack* (*getTrack)(void *data, size_t index);

    status_t (*getTrackMetaData)(

            void *data,

            MetaDataBase& meta,

            size_t index, uint32_t flags);



    status_t (*getMetaData)(void *data, MetaDataBase& meta);

    uint32_t (*flags)(void *data);

    status_t (*setMediaCas)(void *data, const uint8_t* casToken, size_t size);

    const char * (*name)(void *data);

};



struct CMediaExtractorV2 {

    void *data;



    void (*free)(void *data);

    size_t (*countTracks)(void *data);

    CMediaTrackV2* (*getTrack)(void *data, size_t index);

    media_status_t (*getTrackMetaData)(

            void *data,

            AMediaFormat *meta,
@@ -138,48 +99,19 @@ struct CMediaExtractorV2 { 
    const char * (*name)(void *data);

};



struct CMediaExtractorV3 {

    void *data;



    void (*free)(void *data);

    size_t (*countTracks)(void *data);

    CMediaTrackV3* (*getTrack)(void *data, size_t index);

    media_status_t (*getTrackMetaData)(

            void *data,

            AMediaFormat *meta,

            size_t index, uint32_t flags);



    media_status_t (*getMetaData)(void *data, AMediaFormat *meta);

    uint32_t (*flags)(void *data);

    media_status_t (*setMediaCas)(void *data, const uint8_t* casToken, size_t size);

    const char * (*name)(void *data);

};



typedef CMediaExtractorV1* (*CreatorFuncV1)(CDataSource *source, void *meta);

typedef CMediaExtractor* (*CreatorFunc)(CDataSource *source, void *meta);

typedef void (*FreeMetaFunc)(void *meta);



// The sniffer can optionally fill in an opaque object, "meta", that helps

// the corresponding extractor initialize its state without duplicating

// effort already exerted by the sniffer. If "freeMeta" is given, it will be

// called against the opaque object when it is no longer used.

typedef CreatorFuncV1 (*SnifferFuncV1)(

        CDataSource *source, float *confidence,

        void **meta, FreeMetaFunc *freeMeta);



typedef CMediaExtractorV2* (*CreatorFuncV2)(CDataSource *source, void *meta);



typedef CreatorFuncV2 (*SnifferFuncV2)(

        CDataSource *source, float *confidence,

        void **meta, FreeMetaFunc *freeMeta);



typedef CMediaExtractorV3* (*CreatorFuncV3)(CDataSource *source, void *meta);



typedef CreatorFuncV3 (*SnifferFuncV3)(

typedef CreatorFunc (*SnifferFunc)(

        CDataSource *source, float *confidence,

        void **meta, FreeMetaFunc *freeMeta);



typedef CMediaExtractorV1 CMediaExtractor;

typedef CreatorFuncV1 CreatorFunc;

typedef CMediaExtractor CMediaExtractor;

typedef CreatorFunc CreatorFunc;





typedef struct {
@@ -203,16 +135,17 @@ struct ExtractorDef { 
    const char *extractor_name;



    union {

        SnifferFuncV1 v1;

        SnifferFuncV2 v2;

        SnifferFuncV3 v3;

        SnifferFunc v2;

    } sniff;

};



// the C++ based API which first shipped in P and is no longer supported

const uint32_t EXTRACTORDEF_VERSION_LEGACY = 1;

const uint32_t EXTRACTORDEF_VERSION_CURRENT = 2;



const uint32_t EXTRACTORDEF_VERSION = EXTRACTORDEF_VERSION_LEGACY;

// the first C/NDK based API

const uint32_t EXTRACTORDEF_VERSION_NDK_V1 = 2;



const uint32_t EXTRACTORDEF_VERSION = EXTRACTORDEF_VERSION_NDK_V1;



// each plugin library exports one function of this type

typedef ExtractorDef (*GetExtractorDef)();

include/media/MediaExtractorPluginHelper.h

+44 −347
Original line number Diff line number Diff line
@@ -35,155 +35,18 @@ class MetaDataBase; 
struct MediaTrack;





class MediaTrackHelper {

public:

    virtual ~MediaTrackHelper() {};

    virtual status_t start() = 0;

    virtual status_t stop() = 0;

    virtual status_t getFormat(MetaDataBase& format) = 0;

class MediaTrackHelper;



    class ReadOptions {

    public:

        enum SeekMode : int32_t {

            SEEK_PREVIOUS_SYNC,

            SEEK_NEXT_SYNC,

            SEEK_CLOSEST_SYNC,

            SEEK_CLOSEST,

            SEEK_FRAME_INDEX,

        };



        ReadOptions(uint32_t options, int64_t seekPosUs) {

            mOptions = options;

            mSeekPosUs = seekPosUs;

        }

        bool getSeekTo(int64_t *time_us, SeekMode *mode) const {

            if ((mOptions & CMediaTrackReadOptions::SEEK) == 0) {

                return false;

            }

            *time_us = mSeekPosUs;

            *mode = (SeekMode) (mOptions & 7);

            return true;

        }

        bool getNonBlocking() const {

            return mOptions & CMediaTrackReadOptions::NONBLOCKING;

        }

class MediaBufferHelper {

private:

        uint32_t mOptions;

        int64_t mSeekPosUs;

    };



    virtual status_t read(

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

    virtual bool supportsNonBlockingRead() { return false; }

};



inline CMediaTrack *wrap(MediaTrackHelper *track) {

    CMediaTrack *wrapper = (CMediaTrack*) malloc(sizeof(CMediaTrack));

    wrapper->data = track;

    wrapper->free = [](void *data) -> void {

        delete (MediaTrackHelper*)(data);

    };

    wrapper->start = [](void *data) -> status_t {

        return ((MediaTrackHelper*)data)->start();

    };

    wrapper->stop = [](void *data) -> status_t {

        return ((MediaTrackHelper*)data)->stop();

    };

    wrapper->getFormat = [](void *data, MetaDataBase &meta) -> status_t {

        return ((MediaTrackHelper*)data)->getFormat(meta);

    };

    wrapper->read = [](void *data, MediaBufferBase **buffer,  uint32_t options, int64_t seekPosUs)

            -> status_t {

        MediaTrackHelper::ReadOptions opts(options, seekPosUs);

        return ((MediaTrackHelper*)data)->read(buffer, &opts);

    };

    wrapper->supportsNonBlockingRead = [](void *data) -> bool {

                return ((MediaTrackHelper*)data)->supportsNonBlockingRead();

    };

    return wrapper;

}





class MediaTrackHelperV2 {

public:

    virtual ~MediaTrackHelperV2() {};

    virtual media_status_t start() = 0;

    virtual media_status_t stop() = 0;

    virtual media_status_t getFormat(AMediaFormat *format) = 0;



    class ReadOptions {

    friend CMediaTrack *wrap(MediaTrackHelper *);

    CMediaBuffer *mBuffer;

public:

        enum SeekMode : int32_t {

            SEEK_PREVIOUS_SYNC,

            SEEK_NEXT_SYNC,

            SEEK_CLOSEST_SYNC,

            SEEK_CLOSEST,

            SEEK_FRAME_INDEX,

        };



        ReadOptions(uint32_t options, int64_t seekPosUs) {

            mOptions = options;

            mSeekPosUs = seekPosUs;

        }

        bool getSeekTo(int64_t *time_us, SeekMode *mode) const {

            if ((mOptions & CMediaTrackReadOptions::SEEK) == 0) {

                return false;

            }

            *time_us = mSeekPosUs;

            *mode = (SeekMode) (mOptions & 7);

            return true;

        }

        bool getNonBlocking() const {

            return mOptions & CMediaTrackReadOptions::NONBLOCKING;

        }

    private:

        uint32_t mOptions;

        int64_t mSeekPosUs;

    };



    virtual media_status_t read(

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

    virtual bool supportsNonBlockingRead() { return false; }

};



inline CMediaTrackV2 *wrapV2(MediaTrackHelperV2 *track) {

    CMediaTrackV2 *wrapper = (CMediaTrackV2*) malloc(sizeof(CMediaTrackV2));

    wrapper->data = track;

    wrapper->free = [](void *data) -> void {

        delete (MediaTrackHelperV2*)(data);

    };

    wrapper->start = [](void *data) -> media_status_t {

        return ((MediaTrackHelperV2*)data)->start();

    };

    wrapper->stop = [](void *data) -> media_status_t {

        return ((MediaTrackHelperV2*)data)->stop();

    };

    wrapper->getFormat = [](void *data, AMediaFormat *meta) -> media_status_t {

        return ((MediaTrackHelperV2*)data)->getFormat(meta);

    };

    wrapper->read = [](void *data, MediaBufferBase **buffer,  uint32_t options, int64_t seekPosUs)

            -> media_status_t {

        MediaTrackHelperV2::ReadOptions opts(options, seekPosUs);

        return ((MediaTrackHelperV2*)data)->read(buffer, &opts);

    };

    wrapper->supportsNonBlockingRead = [](void *data) -> bool {

                return ((MediaTrackHelperV2*)data)->supportsNonBlockingRead();

    };

    return wrapper;

}



class MediaTrackHelperV3;



class MediaBufferHelperV3 {

private:

    friend CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *);

    CMediaBufferV3 *mBuffer;

public:

    MediaBufferHelperV3(CMediaBufferV3 *buf) {

    MediaBufferHelper(CMediaBuffer *buf) {

        mBuffer = buf;

    }



    virtual ~MediaBufferHelperV3() {}

    virtual ~MediaBufferHelper() {}



    virtual void release() {

        mBuffer->release(mBuffer->handle);
@@ -213,15 +76,15 @@ public: 
    }

};



class MediaBufferGroupHelperV3 {

class MediaBufferGroupHelper {

private:

    CMediaBufferGroupV3 *mGroup;

    std::map<CMediaBufferV3*, MediaBufferHelperV3*> mBufferHelpers;

    CMediaBufferGroup *mGroup;

    std::map<CMediaBuffer*, MediaBufferHelper*> mBufferHelpers;

public:

    MediaBufferGroupHelperV3(CMediaBufferGroupV3 *group) {

    MediaBufferGroupHelper(CMediaBufferGroup *group) {

        mGroup = group;

    }

    ~MediaBufferGroupHelperV3() {

    ~MediaBufferGroupHelper() {

        // delete all entries in map

        ALOGV("buffergroup %p map has %zu entries", this, mBufferHelpers.size());

        for (auto it = mBufferHelpers.begin(); it != mBufferHelpers.end(); ++it) {
@@ -235,14 +98,14 @@ public: 
        mGroup->add_buffer(mGroup->handle, size);

    }

    media_status_t acquire_buffer(

            MediaBufferHelperV3 **buffer, bool nonBlocking = false, size_t requestedSize = 0) {

        CMediaBufferV3 *buf = nullptr;

            MediaBufferHelper **buffer, bool nonBlocking = false, size_t requestedSize = 0) {

        CMediaBuffer *buf = nullptr;

        media_status_t ret =

                mGroup->acquire_buffer(mGroup->handle, &buf, nonBlocking, requestedSize);

        if (ret == AMEDIA_OK && buf != nullptr) {

            auto helper = mBufferHelpers.find(buf);

            if (helper == mBufferHelpers.end()) {

                MediaBufferHelperV3* newHelper = new MediaBufferHelperV3(buf);

                MediaBufferHelper* newHelper = new MediaBufferHelper(buf);

                mBufferHelpers.insert(std::make_pair(buf, newHelper));

                *buffer = newHelper;

            } else {
@@ -258,11 +121,11 @@ public: 
    }

};



class MediaTrackHelperV3 {

class MediaTrackHelper {

public:

    MediaTrackHelperV3() : mBufferGroup(nullptr) {

    MediaTrackHelper() : mBufferGroup(nullptr) {

    }

    virtual ~MediaTrackHelperV3() {

    virtual ~MediaTrackHelper() {

        delete mBufferGroup;

    }

    virtual media_status_t start() = 0;
@@ -300,45 +163,45 @@ public: 
    };



    virtual media_status_t read(

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

            MediaBufferHelper **buffer, const ReadOptions *options = NULL) = 0;

    virtual bool supportsNonBlockingRead() { return false; }

protected:

    friend CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *track);

    MediaBufferGroupHelperV3 *mBufferGroup;

    friend CMediaTrack *wrap(MediaTrackHelper *track);

    MediaBufferGroupHelper *mBufferGroup;

};



inline CMediaTrackV3 *wrapV3(MediaTrackHelperV3 *track) {

    CMediaTrackV3 *wrapper = (CMediaTrackV3*) malloc(sizeof(CMediaTrackV3));

inline CMediaTrack *wrap(MediaTrackHelper *track) {

    CMediaTrack *wrapper = (CMediaTrack*) malloc(sizeof(CMediaTrack));

    wrapper->data = track;

    wrapper->free = [](void *data) -> void {

        delete (MediaTrackHelperV3*)(data);

        delete (MediaTrackHelper*)(data);

    };

    wrapper->start = [](void *data, CMediaBufferGroupV3 *bufferGroup) -> media_status_t {

        if (((MediaTrackHelperV3*)data)->mBufferGroup) {

    wrapper->start = [](void *data, CMediaBufferGroup *bufferGroup) -> media_status_t {

        if (((MediaTrackHelper*)data)->mBufferGroup) {

            // this shouldn't happen, but handle it anyway

            delete ((MediaTrackHelperV3*)data)->mBufferGroup;

            delete ((MediaTrackHelper*)data)->mBufferGroup;

        }

        ((MediaTrackHelperV3*)data)->mBufferGroup = new MediaBufferGroupHelperV3(bufferGroup);

        return ((MediaTrackHelperV3*)data)->start();

        ((MediaTrackHelper*)data)->mBufferGroup = new MediaBufferGroupHelper(bufferGroup);

        return ((MediaTrackHelper*)data)->start();

    };

    wrapper->stop = [](void *data) -> media_status_t {

        return ((MediaTrackHelperV3*)data)->stop();

        return ((MediaTrackHelper*)data)->stop();

    };

    wrapper->getFormat = [](void *data, AMediaFormat *meta) -> media_status_t {

        return ((MediaTrackHelperV3*)data)->getFormat(meta);

        return ((MediaTrackHelper*)data)->getFormat(meta);

    };

    wrapper->read = [](void *data, CMediaBufferV3 **buffer,  uint32_t options, int64_t seekPosUs)

    wrapper->read = [](void *data, CMediaBuffer **buffer,  uint32_t options, int64_t seekPosUs)

            -> media_status_t {

        MediaTrackHelperV3::ReadOptions opts(options, seekPosUs);

        MediaBufferHelperV3 *buf = NULL;

        media_status_t ret = ((MediaTrackHelperV3*)data)->read(&buf, &opts);

        MediaTrackHelper::ReadOptions opts(options, seekPosUs);

        MediaBufferHelper *buf = NULL;

        media_status_t ret = ((MediaTrackHelper*)data)->read(&buf, &opts);

        if (ret == AMEDIA_OK && buf != nullptr) {

            *buffer = buf->mBuffer;

        }

        return ret;

    };

    wrapper->supportsNonBlockingRead = [](void *data) -> bool {

                return ((MediaTrackHelperV3*)data)->supportsNonBlockingRead();

                return ((MediaTrackHelper*)data)->supportsNonBlockingRead();

    };

    return wrapper;

}
@@ -356,13 +219,13 @@ public: 
    enum GetTrackMetaDataFlags {

        kIncludeExtensiveMetaData = 1

    };

    virtual status_t getTrackMetaData(

            MetaDataBase& meta,

    virtual media_status_t getTrackMetaData(

            AMediaFormat *meta,

            size_t index, uint32_t flags = 0) = 0;



    // Return container specific meta-data. The default implementation

    // returns an empty metadata object.

    virtual status_t getMetaData(MetaDataBase& meta) = 0;

    virtual media_status_t getMetaData(AMediaFormat *meta) = 0;



    enum Flags {

        CAN_SEEK_BACKWARD  = 1,  // the "seek 10secs back button"
@@ -377,8 +240,8 @@ public: 
        return CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE;

    };



    virtual status_t setMediaCas(const uint8_t* /*casToken*/, size_t /*size*/) {

        return INVALID_OPERATION;

    virtual media_status_t setMediaCas(const uint8_t* /*casToken*/, size_t /*size*/) {

        return AMEDIA_ERROR_INVALID_OPERATION;

    }



    virtual const char * name() { return "<unspecified>"; }
@@ -405,13 +268,13 @@ inline CMediaExtractor *wrap(MediaExtractorPluginHelper *extractor) { 
    };

    wrapper->getTrackMetaData = [](

            void *data,

            MetaDataBase& meta,

            size_t index, uint32_t flags) -> status_t {

            AMediaFormat *meta,

            size_t index, uint32_t flags) -> media_status_t {

        return ((MediaExtractorPluginHelper*)data)->getTrackMetaData(meta, index, flags);

    };

    wrapper->getMetaData = [](

            void *data,

            MetaDataBase& meta) -> status_t {

            AMediaFormat *meta) -> media_status_t {

        return ((MediaExtractorPluginHelper*)data)->getMetaData(meta);

    };

    wrapper->flags = [](
@@ -419,7 +282,7 @@ inline CMediaExtractor *wrap(MediaExtractorPluginHelper *extractor) { 
        return ((MediaExtractorPluginHelper*)data)->flags();

    };

    wrapper->setMediaCas = [](

            void *data, const uint8_t *casToken, size_t size) -> status_t {

            void *data, const uint8_t *casToken, size_t size) -> media_status_t {

        return ((MediaExtractorPluginHelper*)data)->setMediaCas(casToken, size);

    };

    wrapper->name = [](
@@ -429,172 +292,6 @@ inline CMediaExtractor *wrap(MediaExtractorPluginHelper *extractor) { 
    return wrapper;

}



class MediaExtractorPluginHelperV2

{

public:

    virtual ~MediaExtractorPluginHelperV2() {}

    virtual size_t countTracks() = 0;

    virtual MediaTrackHelperV2 *getTrack(size_t index) = 0;



    enum GetTrackMetaDataFlags {

        kIncludeExtensiveMetaData = 1

    };

    virtual media_status_t getTrackMetaData(

            AMediaFormat *meta,

            size_t index, uint32_t flags = 0) = 0;



    // Return container specific meta-data. The default implementation

    // returns an empty metadata object.

    virtual media_status_t getMetaData(AMediaFormat *meta) = 0;



    enum Flags {

        CAN_SEEK_BACKWARD  = 1,  // the "seek 10secs back button"

        CAN_SEEK_FORWARD   = 2,  // the "seek 10secs forward button"

        CAN_PAUSE          = 4,

        CAN_SEEK           = 8,  // the "seek bar"

    };



    // If subclasses do _not_ override this, the default is

    // CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE

    virtual uint32_t flags() const {

        return CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE;

    };



    virtual media_status_t setMediaCas(const uint8_t* /*casToken*/, size_t /*size*/) {

        return AMEDIA_ERROR_INVALID_OPERATION;

    }



    virtual const char * name() { return "<unspecified>"; }



protected:

    MediaExtractorPluginHelperV2() {}



private:

    MediaExtractorPluginHelperV2(const MediaExtractorPluginHelperV2 &);

    MediaExtractorPluginHelperV2 &operator=(const MediaExtractorPluginHelperV2 &);

};



inline CMediaExtractorV2 *wrapV2(MediaExtractorPluginHelperV2 *extractor) {

    CMediaExtractorV2 *wrapper = (CMediaExtractorV2*) malloc(sizeof(CMediaExtractorV2));

    wrapper->data = extractor;

    wrapper->free = [](void *data) -> void {

        delete (MediaExtractorPluginHelperV2*)(data);

    };

    wrapper->countTracks = [](void *data) -> size_t {

        return ((MediaExtractorPluginHelperV2*)data)->countTracks();

    };

    wrapper->getTrack = [](void *data, size_t index) -> CMediaTrackV2* {

        return wrapV2(((MediaExtractorPluginHelperV2*)data)->getTrack(index));

    };

    wrapper->getTrackMetaData = [](

            void *data,

            AMediaFormat *meta,

            size_t index, uint32_t flags) -> media_status_t {

        return ((MediaExtractorPluginHelperV2*)data)->getTrackMetaData(meta, index, flags);

    };

    wrapper->getMetaData = [](

            void *data,

            AMediaFormat *meta) -> media_status_t {

        return ((MediaExtractorPluginHelperV2*)data)->getMetaData(meta);

    };

    wrapper->flags = [](

            void *data) -> uint32_t {

        return ((MediaExtractorPluginHelperV2*)data)->flags();

    };

    wrapper->setMediaCas = [](

            void *data, const uint8_t *casToken, size_t size) -> media_status_t {

        return ((MediaExtractorPluginHelperV2*)data)->setMediaCas(casToken, size);

    };

    wrapper->name = [](

            void *data) -> const char * {

        return ((MediaExtractorPluginHelperV2*)data)->name();

    };

    return wrapper;

}



class MediaExtractorPluginHelperV3

{

public:

    virtual ~MediaExtractorPluginHelperV3() {}

    virtual size_t countTracks() = 0;

    virtual MediaTrackHelperV3 *getTrack(size_t index) = 0;



    enum GetTrackMetaDataFlags {

        kIncludeExtensiveMetaData = 1

    };

    virtual media_status_t getTrackMetaData(

            AMediaFormat *meta,

            size_t index, uint32_t flags = 0) = 0;



    // Return container specific meta-data. The default implementation

    // returns an empty metadata object.

    virtual media_status_t getMetaData(AMediaFormat *meta) = 0;



    enum Flags {

        CAN_SEEK_BACKWARD  = 1,  // the "seek 10secs back button"

        CAN_SEEK_FORWARD   = 2,  // the "seek 10secs forward button"

        CAN_PAUSE          = 4,

        CAN_SEEK           = 8,  // the "seek bar"

    };



    // If subclasses do _not_ override this, the default is

    // CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE

    virtual uint32_t flags() const {

        return CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE;

    };



    virtual media_status_t setMediaCas(const uint8_t* /*casToken*/, size_t /*size*/) {

        return AMEDIA_ERROR_INVALID_OPERATION;

    }



    virtual const char * name() { return "<unspecified>"; }



protected:

    MediaExtractorPluginHelperV3() {}



private:

    MediaExtractorPluginHelperV3(const MediaExtractorPluginHelperV2 &);

    MediaExtractorPluginHelperV3 &operator=(const MediaExtractorPluginHelperV2 &);

};



inline CMediaExtractorV3 *wrapV3(MediaExtractorPluginHelperV3 *extractor) {

    CMediaExtractorV3 *wrapper = (CMediaExtractorV3*) malloc(sizeof(CMediaExtractorV3));

    wrapper->data = extractor;

    wrapper->free = [](void *data) -> void {

        delete (MediaExtractorPluginHelperV3*)(data);

    };

    wrapper->countTracks = [](void *data) -> size_t {

        return ((MediaExtractorPluginHelperV3*)data)->countTracks();

    };

    wrapper->getTrack = [](void *data, size_t index) -> CMediaTrackV3* {

        return wrapV3(((MediaExtractorPluginHelperV3*)data)->getTrack(index));

    };

    wrapper->getTrackMetaData = [](

            void *data,

            AMediaFormat *meta,

            size_t index, uint32_t flags) -> media_status_t {

        return ((MediaExtractorPluginHelperV3*)data)->getTrackMetaData(meta, index, flags);

    };

    wrapper->getMetaData = [](

            void *data,

            AMediaFormat *meta) -> media_status_t {

        return ((MediaExtractorPluginHelperV3*)data)->getMetaData(meta);

    };

    wrapper->flags = [](

            void *data) -> uint32_t {

        return ((MediaExtractorPluginHelperV3*)data)->flags();

    };

    wrapper->setMediaCas = [](

            void *data, const uint8_t *casToken, size_t size) -> media_status_t {

        return ((MediaExtractorPluginHelperV3*)data)->setMediaCas(casToken, size);

    };

    wrapper->name = [](

            void *data) -> const char * {

        return ((MediaExtractorPluginHelperV3*)data)->name();

    };

    return wrapper;

}



/* adds some convience methods */

class DataSourceHelper {

public:

include/media/MediaTrack.h

+0 −36
Original line number Diff line number Diff line
@@ -156,42 +156,6 @@ protected: 


private:

    CMediaTrack *wrapper;

};



class MediaTrackCUnwrapperV2 : public MediaTrack {

public:

    explicit MediaTrackCUnwrapperV2(CMediaTrackV2 *wrapper);



    virtual status_t start();

    virtual status_t stop();

    virtual status_t getFormat(MetaDataBase& format);

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



    virtual bool supportNonblockingRead();



protected:

    virtual ~MediaTrackCUnwrapperV2();



private:

    CMediaTrackV2 *wrapper;

};



class MediaTrackCUnwrapperV3 : public MediaTrack {

public:

    explicit MediaTrackCUnwrapperV3(CMediaTrackV3 *wrapper);



    virtual status_t start();

    virtual status_t stop();

    virtual status_t getFormat(MetaDataBase& format);

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



    virtual bool supportNonblockingRead();



protected:

    virtual ~MediaTrackCUnwrapperV3();



private:

    CMediaTrackV3 *wrapper;

    MediaBufferGroup *bufferGroup;

};

media/extractors/aac/AACExtractor.cpp

+10 −10

File changed.

Preview size limit exceeded, changes collapsed.

media/extractors/aac/AACExtractor.h

+2 −2
Original line number Diff line number Diff line
@@ -29,12 +29,12 @@ namespace android { 
struct AMessage;

class String8;



class AACExtractor : public MediaExtractorPluginHelperV3 {

class AACExtractor : public MediaExtractorPluginHelper {

public:

    AACExtractor(DataSourceHelper *source, off64_t offset);



    virtual size_t countTracks();

    virtual MediaTrackHelperV3 *getTrack(size_t index);

    virtual MediaTrackHelper *getTrack(size_t index);

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



    virtual media_status_t getMetaData(AMediaFormat *meta);