Only export necessary symbols (3425fd5a) · Commits · e / os / android_frameworks_av

media/ndk/Android.mk

+2 −0

Original line number	Diff line number	Diff line
		@@ -35,6 +35,8 @@ LOCAL_C_INCLUDES := \
		frameworks/base/core/jni \
		frameworks/av/include/ndk

		LOCAL_CFLAGS += -fvisibility=hidden -D EXPORT='__attribute__ ((visibility ("default")))'

		LOCAL_SHARED_LIBRARIES := \
		libbinder \
		libmedia \

media/ndk/NdkMediaCodec.cpp

+25 −1

Original line number	Diff line number	Diff line
		@@ -159,19 +159,22 @@ static AMediaCodec * createAMediaCodec(const char *name, bool name_is_type, bool
		return mData;
		}


		EXPORT
		AMediaCodec* AMediaCodec_createCodecByName(const char *name) {
		return createAMediaCodec(name, false, false);
		}

		EXPORT
		AMediaCodec* AMediaCodec_createDecoderByType(const char *mime_type) {
		return createAMediaCodec(mime_type, true, false);
		}

		EXPORT
		AMediaCodec* AMediaCodec_createEncoderByType(const char *name) {
		return createAMediaCodec(name, true, true);
		}

		EXPORT
		int AMediaCodec_delete(AMediaCodec *mData) {
		if (mData->mCodec != NULL) {
		mData->mCodec->release();
		@@ -187,6 +190,7 @@ int AMediaCodec_delete(AMediaCodec *mData) {
		return OK;
		}

		EXPORT
		int AMediaCodec_configure(
		AMediaCodec *mData,
		const AMediaFormat* format,
		@@ -205,6 +209,7 @@ int AMediaCodec_configure(
		crypto ? crypto->mCrypto : NULL, flags));
		}

		EXPORT
		int AMediaCodec_start(AMediaCodec *mData) {
		status_t ret = mData->mCodec->start();
		if (ret != OK) {
		@@ -216,6 +221,7 @@ int AMediaCodec_start(AMediaCodec *mData) {
		return OK;
		}

		EXPORT
		int AMediaCodec_stop(AMediaCodec *mData) {
		int ret = translate_error(mData->mCodec->stop());

		@@ -227,10 +233,12 @@ int AMediaCodec_stop(AMediaCodec *mData) {
		return ret;
		}

		EXPORT
		int AMediaCodec_flush(AMediaCodec *mData) {
		return translate_error(mData->mCodec->flush());
		}

		EXPORT
		ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec *mData, int64_t timeoutUs) {
		size_t idx;
		status_t ret = mData->mCodec->dequeueInputBuffer(&idx, timeoutUs);
		@@ -241,6 +249,7 @@ ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec *mData, int64_t timeoutUs) {
		return translate_error(ret);
		}

		EXPORT
		uint8_t* AMediaCodec_getInputBuffer(AMediaCodec mData, size_t idx, size_t out_size) {
		android::Vector<android::sp<android::ABuffer> > abufs;
		if (mData->mCodec->getInputBuffers(&abufs) == 0) {
		@@ -258,6 +267,7 @@ uint8_t* AMediaCodec_getInputBuffer(AMediaCodec mData, size_t idx, size_t out_
		return NULL;
		}

		EXPORT
		uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec mData, size_t idx, size_t out_size) {
		android::Vector<android::sp<android::ABuffer> > abufs;
		if (mData->mCodec->getOutputBuffers(&abufs) == 0) {
		@@ -275,6 +285,7 @@ uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec mData, size_t idx, size_t out
		return NULL;
		}

		EXPORT
		int AMediaCodec_queueInputBuffer(AMediaCodec *mData,
		size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags) {

		@@ -283,6 +294,7 @@ int AMediaCodec_queueInputBuffer(AMediaCodec *mData,
		return translate_error(ret);
		}

		EXPORT
		ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec *mData,
		AMediaCodecBufferInfo *info, int64_t timeoutUs) {
		size_t idx;
		@@ -312,12 +324,14 @@ ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec *mData,
		return translate_error(ret);
		}

		EXPORT
		AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec *mData) {
		sp<AMessage> format;
		mData->mCodec->getOutputFormat(&format);
		return AMediaFormat_fromMsg(&format);
		}

		EXPORT
		int AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render) {
		if (render) {
		return translate_error(mData->mCodec->renderOutputBufferAndRelease(idx));
		@@ -326,6 +340,7 @@ int AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render)
		}
		}

		EXPORT
		int AMediaCodec_setNotificationCallback(AMediaCodec mData, OnCodecEvent callback, void userdata) {
		mData->mCallback = callback;
		mData->mCallbackUserData = userdata;
		@@ -341,6 +356,7 @@ typedef struct AMediaCodecCryptoInfo {
		size_t *encryptedbytes;
		} AMediaCodecCryptoInfo;

		EXPORT
		int AMediaCodec_queueSecureInputBuffer(
		AMediaCodec* codec,
		size_t idx,
		@@ -375,6 +391,7 @@ int AMediaCodec_queueSecureInputBuffer(



		EXPORT
		AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new(
		int numsubsamples,
		uint8_t key[16],
		@@ -406,15 +423,18 @@ AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new(
		}


		EXPORT
		int AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo* info) {
		free(info);
		return OK;
		}

		EXPORT
		size_t AMediaCodecCryptoInfo_getNumSubSamples(AMediaCodecCryptoInfo* ci) {
		return ci->numsubsamples;
		}

		EXPORT
		int AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
		if (!dst \|\| !ci) {
		return AMEDIAERROR_UNSUPPORTED;
		@@ -423,6 +443,7 @@ int AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
		return OK;
		}

		EXPORT
		int AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
		if (!dst \|\| !ci) {
		return AMEDIAERROR_UNSUPPORTED;
		@@ -431,6 +452,7 @@ int AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
		return OK;
		}

		EXPORT
		uint32_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo* ci) {
		if (!ci) {
		return AMEDIAERROR_UNSUPPORTED;
		@@ -438,6 +460,7 @@ uint32_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo* ci) {
		return ci->mode;
		}

		EXPORT
		int AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo* ci, size_t *dst) {
		if (!dst \|\| !ci) {
		return AMEDIAERROR_UNSUPPORTED;
		@@ -446,6 +469,7 @@ int AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo* ci, size_t *dst)
		return OK;
		}

		EXPORT
		int AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo* ci, size_t *dst) {
		if (!dst \|\| !ci) {
		return AMEDIAERROR_UNSUPPORTED;

media/ndk/NdkMediaCrypto.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -74,6 +74,7 @@ struct AMediaCrypto {
		extern "C" {


		EXPORT
		bool AMediaCrypto_isCryptoSchemeSupported(const AMediaUUID uuid) {
		sp<ICrypto> crypto = makeCrypto();
		if (crypto == NULL) {
		@@ -82,6 +83,7 @@ bool AMediaCrypto_isCryptoSchemeSupported(const AMediaUUID uuid) {
		return crypto->isCryptoSchemeSupported(uuid);
		}

		EXPORT
		bool AMediaCrypto_requiresSecureDecoderComponent(const char *mime) {
		sp<ICrypto> crypto = makeCrypto();
		if (crypto == NULL) {
		@@ -90,6 +92,7 @@ bool AMediaCrypto_requiresSecureDecoderComponent(const char *mime) {
		return crypto->requiresSecureDecoderComponent(mime);
		}

		EXPORT
		AMediaCrypto* AMediaCrypto_new(const AMediaUUID uuid, const void *data, size_t datasize) {

		sp<ICrypto> tmp = makeCrypto();
		@@ -107,6 +110,7 @@ AMediaCrypto* AMediaCrypto_new(const AMediaUUID uuid, const void *data, size_t d
		return crypto;
		}

		EXPORT
		void AMediaCrypto_delete(AMediaCrypto* crypto) {
		delete crypto;
		}

media/ndk/NdkMediaDrm.cpp

+22 −0

Original line number	Diff line number	Diff line
		@@ -127,6 +127,7 @@ static sp<IDrm> CreateDrmFromUUID(const AMediaUUID uuid) {
		return drm;
		}

		EXPORT
		bool AMediaDrm_isCryptoSchemeSupported(const AMediaUUID uuid, const char *mimeType) {
		sp<IDrm> drm = CreateDrm();

		@@ -138,12 +139,14 @@ bool AMediaDrm_isCryptoSchemeSupported(const AMediaUUID uuid, const char *mimeTy
		return drm->isCryptoSchemeSupported(uuid, mimeStr);
		}

		EXPORT
		AMediaDrm* AMediaDrm_createByUUID(const AMediaUUID uuid) {
		AMediaDrm *mObj = new AMediaDrm();
		mObj->mDrm = CreateDrmFromUUID(uuid);
		return mObj;
		}

		EXPORT
		void AMediaDrm_release(AMediaDrm *mObj) {
		if (mObj->mDrm != NULL) {
		mObj->mDrm->setListener(NULL);
		@@ -170,6 +173,7 @@ static bool findId(AMediaDrm *mObj, const AMediaDrmByteArray &id, List<idvec_t>:
		return false;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &sessionId) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return MEDIADRM_INVALID_OBJECT_ERROR;
		@@ -185,6 +189,7 @@ mediadrm_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &ses
		return MEDIADRM_OK;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_closeSession(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return MEDIADRM_INVALID_OBJECT_ERROR;
		@@ -199,6 +204,7 @@ mediadrm_status_t AMediaDrm_closeSession(AMediaDrm *mObj, const AMediaDrmSession
		return MEDIADRM_OK;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope &scope,
		const uint8_t init, size_t initSize, const char mimeType, AMediaDrmKeyType keyType,
		const AMediaDrmKeyValue *optionalParameters, size_t numOptionalParameters,
		@@ -249,6 +255,7 @@ mediadrm_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope
		return MEDIADRM_OK;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *mObj, const AMediaDrmScope &scope,
		const uint8_t *response, size_t responseSize, AMediaDrmKeySetId &keySetId) {

		@@ -280,6 +287,7 @@ mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *mObj, const AMediaDrmS
		return MEDIADRM_OK;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		const AMediaDrmKeySetId &keySetId) {

		@@ -295,6 +303,7 @@ mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *mObj, const AMediaDrmSessionI
		return translateStatus(mObj->mDrm->restoreKeys(*iter, keySet));
		}

		EXPORT
		mediadrm_status_t AMediaDrm_removeKeys(AMediaDrm *mObj, const AMediaDrmSessionId &keySetId) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return MEDIADRM_INVALID_OBJECT_ERROR;
		@@ -312,6 +321,7 @@ mediadrm_status_t AMediaDrm_removeKeys(AMediaDrm *mObj, const AMediaDrmSessionId
		return translateStatus(status);
		}

		EXPORT
		mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		AMediaDrmKeyValue *keyValuePairs, size_t &numPairs) {

		@@ -342,6 +352,7 @@ mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessi
		return MEDIADRM_OK;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm mObj, const uint8_t &provisionRequest,
		size_t &provisionRequestSize, const char *&serverUrl) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		@@ -363,6 +374,7 @@ mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm mObj, const uint8_t
		return MEDIADRM_OK;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj,
		const uint8_t *response, size_t responseSize) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		@@ -379,6 +391,7 @@ mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj,
		return translateStatus(mObj->mDrm->provideProvisionResponse(mdResponse, unused, unused));
		}

		EXPORT
		mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj,
		AMediaDrmSecureStop *secureStops, size_t &numSecureStops) {

		@@ -405,6 +418,7 @@ mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj,
		return MEDIADRM_OK;
		}

		EXPORT
		mediadrm_status_t AMediaDrm_releaseSecureStops(AMediaDrm *mObj,
		const AMediaDrmSecureStop &ssRelease) {

		@@ -418,6 +432,7 @@ mediadrm_status_t AMediaDrm_releaseSecureStops(AMediaDrm *mObj,
		}


		EXPORT
		mediadrm_status_t AMediaDrm_getPropertyString(AMediaDrm mObj, const char propertyName,
		const char *&propertyValue) {

		@@ -436,6 +451,7 @@ mediadrm_status_t AMediaDrm_getPropertyString(AMediaDrm mObj, const char prope
		return translateStatus(status);
		}

		EXPORT
		mediadrm_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj,
		const char *propertyName, AMediaDrmByteArray &propertyValue) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		@@ -455,6 +471,7 @@ mediadrm_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj,
		return translateStatus(status);
		}

		EXPORT
		mediadrm_status_t AMediaDrm_setPropertyString(AMediaDrm *mObj,
		const char propertyName, const char value) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		@@ -465,6 +482,7 @@ mediadrm_status_t AMediaDrm_setPropertyString(AMediaDrm *mObj,
		String8(value)));
		}

		EXPORT
		mediadrm_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *mObj,
		const char propertyName, const uint8_t value, size_t valueSize) {

		@@ -517,6 +535,7 @@ static mediadrm_status_t encrypt_decrypt_common(AMediaDrm *mObj,
		return translateStatus(status);
		}

		EXPORT
		mediadrm_status_t AMediaDrm_encrypt(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		const char cipherAlgorithm, uint8_t keyId, uint8_t *iv,
		const uint8_t input, uint8_t output, size_t dataSize) {
		@@ -524,6 +543,7 @@ mediadrm_status_t AMediaDrm_encrypt(AMediaDrm *mObj, const AMediaDrmSessionId &s
		input, output, dataSize, true);
		}

		EXPORT
		mediadrm_status_t AMediaDrm_decrypt(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		const char cipherAlgorithm, uint8_t keyId, uint8_t *iv,
		const uint8_t input, uint8_t output, size_t dataSize) {
		@@ -531,6 +551,7 @@ mediadrm_status_t AMediaDrm_decrypt(AMediaDrm *mObj, const AMediaDrmSessionId &s
		input, output, dataSize, false);
		}

		EXPORT
		mediadrm_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		const char macAlgorithm, uint8_t keyId, uint8_t *message, size_t messageSize,
		uint8_t signature, size_t signatureSize) {
		@@ -566,6 +587,7 @@ mediadrm_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &sess
		return translateStatus(status);
		}

		EXPORT
		mediadrm_status_t AMediaDrm_verify(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		const char macAlgorithm, uint8_t keyId, const uint8_t *message, size_t messageSize,
		const uint8_t *signature, size_t signatureSize) {

media/ndk/NdkMediaExtractor.cpp

+15 −0

Original line number	Diff line number	Diff line
		@@ -54,6 +54,7 @@ struct AMediaExtractor {

		extern "C" {

		EXPORT
		AMediaExtractor* AMediaExtractor_new() {
		ALOGV("ctor");
		AMediaExtractor *mData = new AMediaExtractor();
		@@ -61,18 +62,21 @@ AMediaExtractor* AMediaExtractor_new() {
		return mData;
		}

		EXPORT
		int AMediaExtractor_delete(AMediaExtractor *mData) {
		ALOGV("dtor");
		delete mData;
		return OK;
		}

		EXPORT
		int AMediaExtractor_setDataSourceFd(AMediaExtractor *mData, int fd, off64_t offset, off64_t length) {
		ALOGV("setDataSource(%d, %lld, %lld)", fd, offset, length);
		mData->mImpl->setDataSource(fd, offset, length);
		return 0;
		}

		EXPORT
		int AMediaExtractor_setDataSource(AMediaExtractor mData, const char location) {
		ALOGV("setDataSource(%s)", location);
		// TODO: add header support
		@@ -116,31 +120,37 @@ int AMediaExtractor_setDataSource(AMediaExtractor mData, const char location)
		return OK;
		}

		EXPORT
		int AMediaExtractor_getTrackCount(AMediaExtractor *mData) {
		return mData->mImpl->countTracks();
		}

		EXPORT
		AMediaFormat* AMediaExtractor_getTrackFormat(AMediaExtractor *mData, size_t idx) {
		sp<AMessage> format;
		mData->mImpl->getTrackFormat(idx, &format);
		return AMediaFormat_fromMsg(&format);
		}

		EXPORT
		int AMediaExtractor_selectTrack(AMediaExtractor *mData, size_t idx) {
		ALOGV("selectTrack(%z)", idx);
		return translate_error(mData->mImpl->selectTrack(idx));
		}

		EXPORT
		int AMediaExtractor_unselectTrack(AMediaExtractor *mData, size_t idx) {
		ALOGV("unselectTrack(%z)", idx);
		return translate_error(mData->mImpl->unselectTrack(idx));
		}

		EXPORT
		bool AMediaExtractor_advance(AMediaExtractor *mData) {
		//ALOGV("advance");
		return mData->mImpl->advance();
		}

		EXPORT
		int AMediaExtractor_readSampleData(AMediaExtractor mData, uint8_t buffer, size_t capacity) {
		//ALOGV("readSampleData");
		sp<ABuffer> tmp = new ABuffer(buffer, capacity);
		@@ -150,6 +160,7 @@ int AMediaExtractor_readSampleData(AMediaExtractor mData, uint8_t buffer, size
		return -1;
		}

		EXPORT
		int AMediaExtractor_getSampleFlags(AMediaExtractor *mData) {
		int sampleFlags = 0;
		sp<MetaData> meta;
		@@ -171,6 +182,7 @@ int AMediaExtractor_getSampleFlags(AMediaExtractor *mData) {
		return sampleFlags;
		}

		EXPORT
		int AMediaExtractor_getSampleTrackIndex(AMediaExtractor *mData) {
		size_t idx;
		if (mData->mImpl->getSampleTrackIndex(&idx) != OK) {
		@@ -179,6 +191,7 @@ int AMediaExtractor_getSampleTrackIndex(AMediaExtractor *mData) {
		return idx;
		}

		EXPORT
		int64_t AMediaExtractor_getSampletime(AMediaExtractor *mData) {
		int64_t time;
		if (mData->mImpl->getSampleTime(&time) != OK) {
		@@ -187,6 +200,7 @@ int64_t AMediaExtractor_getSampletime(AMediaExtractor *mData) {
		return time;
		}

		EXPORT
		PsshInfo* AMediaExtractor_getPsshInfo(AMediaExtractor *ex) {

		if (ex->mPsshBuf != NULL) {
		@@ -267,6 +281,7 @@ PsshInfo* AMediaExtractor_getPsshInfo(AMediaExtractor *ex) {
		return (PsshInfo*) ex->mPsshBuf->data();
		}

		EXPORT
		AMediaCodecCryptoInfo AMediaExtractor_getSampleCryptoInfo(AMediaExtractor ex) {
		sp<MetaData> meta;
		if(ex->mImpl->getSampleMeta(&meta) != 0) {