Merge "Remove support for non-NDK extractor formats" (1b5d1cd0) · Commits · e / os / android_frameworks_av

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