Merge "Convert MPEG2 extractor to V3 format" (be66832f) · Commits · e / os / android_frameworks_av

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;