Add Ndk MediaExtractor wrapper (ff282cbc) · Commits · e / os / android_frameworks_av

media/libmedia/nuplayer2/NdkWrapper.cpp

+123 −1

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@
		#include <media/NdkMediaCrypto.h>
		#include <media/NdkMediaDrm.h>
		#include <media/NdkMediaFormat.h>
		#include <media/NdkMediaExtractor.h>
		#include <media/stagefright/MetaData.h>
		#include <media/stagefright/foundation/ABuffer.h>
		#include <media/stagefright/foundation/AMessage.h>
		@@ -177,7 +178,6 @@ static cryptoinfo_mode_t translateToCryptoInfoMode(CryptoPlugin::Mode mode) {
		return ret;
		}


		//////////// AMediaFormatWrapper
		// static
		sp<AMediaFormatWrapper> AMediaFormatWrapper::Create(const sp<AMessage> &message) {
		@@ -993,4 +993,126 @@ status_t AMediaCodecWrapper::setParameters(const sp<AMediaFormatWrapper> &params
		AMediaCodec_setParameters(mAMediaCodec, params->getAMediaFormat()));
		}

		//////////// AMediaExtractorWrapper

		AMediaExtractorWrapper::AMediaExtractorWrapper(AMediaExtractor *aMediaExtractor)
		: mAMediaExtractor(aMediaExtractor) {
		}

		AMediaExtractorWrapper::~AMediaExtractorWrapper() {
		release();
		}

		status_t AMediaExtractorWrapper::release() {
		if (mAMediaExtractor != NULL) {
		media_status_t err = AMediaExtractor_delete(mAMediaExtractor);
		mAMediaExtractor = NULL;
		return translateErrorCode(err);
		}
		return OK;
		}

		AMediaExtractor *AMediaExtractorWrapper::getAMediaExtractor() const {
		return mAMediaExtractor;
		}

		status_t AMediaExtractorWrapper::setDataSource(int fd, off64_t offset, off64_t length) {
		if (mAMediaExtractor == NULL) {
		return DEAD_OBJECT;
		}
		return translateErrorCode(AMediaExtractor_setDataSourceFd(
		mAMediaExtractor, fd, offset, length));
		}

		status_t AMediaExtractorWrapper::setDataSource(const char *location) {
		if (mAMediaExtractor == NULL) {
		return DEAD_OBJECT;
		}
		return translateErrorCode(AMediaExtractor_setDataSource(mAMediaExtractor, location));
		}

		size_t AMediaExtractorWrapper::getTrackCount() {
		if (mAMediaExtractor == NULL) {
		return 0;
		}
		return AMediaExtractor_getTrackCount(mAMediaExtractor);
		}

		sp<AMediaFormatWrapper> AMediaExtractorWrapper::getTrackFormat(size_t idx) {
		if (mAMediaExtractor == NULL) {
		return NULL;
		}
		return new AMediaFormatWrapper(AMediaExtractor_getTrackFormat(mAMediaExtractor, idx));
		}

		status_t AMediaExtractorWrapper::selectTrack(size_t idx) {
		if (mAMediaExtractor == NULL) {
		return DEAD_OBJECT;
		}
		return translateErrorCode(AMediaExtractor_selectTrack(mAMediaExtractor, idx));
		}

		status_t AMediaExtractorWrapper::unselectTrack(size_t idx) {
		if (mAMediaExtractor == NULL) {
		return DEAD_OBJECT;
		}
		return translateErrorCode(AMediaExtractor_unselectTrack(mAMediaExtractor, idx));
		}

		ssize_t AMediaExtractorWrapper::readSampleData(const sp<ABuffer> &buffer) {
		if (mAMediaExtractor == NULL) {
		return -1;
		}
		return AMediaExtractor_readSampleData(mAMediaExtractor, buffer->data(), buffer->capacity());
		}

		uint32_t AMediaExtractorWrapper::getSampleFlags() {
		if (mAMediaExtractor == NULL) {
		return 0;
		}
		return AMediaExtractor_getSampleFlags(mAMediaExtractor);
		}

		int AMediaExtractorWrapper::getSampleTrackIndex() {
		if (mAMediaExtractor == NULL) {
		return -1;
		}
		return AMediaExtractor_getSampleTrackIndex(mAMediaExtractor);
		}

		int64_t AMediaExtractorWrapper::getSampleTime() {
		if (mAMediaExtractor == NULL) {
		return -1;
		}
		return AMediaExtractor_getSampleTime(mAMediaExtractor);
		}

		bool AMediaExtractorWrapper::advance() {
		if (mAMediaExtractor == NULL) {
		return false;
		}
		return AMediaExtractor_advance(mAMediaExtractor);
		}

		status_t AMediaExtractorWrapper::seekTo(int64_t seekPosUs, SeekMode mode) {
		if (mAMediaExtractor == NULL) {
		return DEAD_OBJECT;
		}
		return AMediaExtractor_seekTo(mAMediaExtractor, seekPosUs, mode);
		}

		PsshInfo* AMediaExtractorWrapper::getPsshInfo() {
		if (mAMediaExtractor == NULL) {
		return NULL;
		}
		return AMediaExtractor_getPsshInfo(mAMediaExtractor);
		}

		sp<AMediaCodecCryptoInfoWrapper> AMediaExtractorWrapper::getSampleCryptoInfo() {
		if (mAMediaExtractor == NULL) {
		return NULL;
		}
		return new AMediaCodecCryptoInfoWrapper(AMediaExtractor_getSampleCryptoInfo(mAMediaExtractor));
		}

		} // namespace android

media/libmedia/nuplayer2/NdkWrapper.h

+51 −0

Original line number	Diff line number	Diff line
		@@ -19,8 +19,10 @@
		#define NDK_WRAPPER_H_

		#include <media/NdkMediaError.h>
		#include <media/NdkMediaExtractor.h>
		#include <media/hardware/CryptoAPI.h>
		#include <media/stagefright/foundation/ABase.h>
		#include <media/stagefright/foundation/ABuffer.h>
		#include <utils/Errors.h>
		#include <utils/RefBase.h>

		@@ -30,6 +32,8 @@ struct AMediaCodecCryptoInfo;
		struct AMediaCrypto;
		struct AMediaDrm;
		struct AMediaFormat;
		struct AMediaExtractor;
		struct PsshInfo;

		namespace android {

		@@ -252,6 +256,53 @@ private:
		DISALLOW_EVIL_CONSTRUCTORS(AMediaCodecWrapper);
		};

		struct AMediaExtractorWrapper : public RefBase {

		AMediaExtractorWrapper(AMediaExtractor *aMediaExtractor);

		// the returned AMediaExtractor is still owned by this wrapper.
		AMediaExtractor *getAMediaExtractor() const;

		status_t release();

		status_t setDataSource(int fd, off64_t offset, off64_t length);

		status_t setDataSource(const char *location);

		size_t getTrackCount();

		sp<AMediaFormatWrapper> getTrackFormat(size_t idx);

		status_t selectTrack(size_t idx);

		status_t unselectTrack(size_t idx);

		ssize_t readSampleData(const sp<ABuffer> &buffer);

		uint32_t getSampleFlags();

		int getSampleTrackIndex();

		int64_t getSampleTime();

		bool advance();

		status_t seekTo(int64_t seekPosUs, SeekMode mode);

		// the returned PsshInfo is still owned by this wrapper.
		PsshInfo* getPsshInfo();

		sp<AMediaCodecCryptoInfoWrapper> getSampleCryptoInfo();

		protected:
		virtual ~AMediaExtractorWrapper();

		private:
		AMediaExtractor *mAMediaExtractor;

		DISALLOW_EVIL_CONSTRUCTORS(AMediaExtractorWrapper);
		};

		} // namespace android

		#endif // NDK_WRAPPER_H_