Merge "Use pointers instead of references because C" (a8570374) · Commits · e / os / android_frameworks_av

include/ndk/NdkMediaDrm.h

+22 −22

Original line number	Diff line number	Diff line
		@@ -77,7 +77,7 @@ typedef enum AMediaDrmEventType {
		EVENT_VENDOR_DEFINED = 4
		} AMediaDrmEventType;

		typedef void (AMediaDrmEventListener)(AMediaDrm , const AMediaDrmSessionId &sessionId,
		typedef void (AMediaDrmEventListener)(AMediaDrm , const AMediaDrmSessionId *sessionId,
		AMediaDrmEventType eventType, int extra, const uint8_t *data, size_t dataSize);


		@@ -115,13 +115,13 @@ media_status_t AMediaDrm_setOnEventListener(AMediaDrm *, AMediaDrmEventListener
		* returns MEDIADRM_NOT_PROVISIONED_ERROR if provisioning is needed
		* returns MEDIADRM_RESOURCE_BUSY_ERROR if required resources are in use
		*/
		media_status_t AMediaDrm_openSession(AMediaDrm *, AMediaDrmSessionId &sessionId);
		media_status_t AMediaDrm_openSession(AMediaDrm , AMediaDrmSessionId sessionId);

		/**
		* Close a session on the MediaDrm object that was previously opened
		* with AMediaDrm_openSession.
		*/
		media_status_t AMediaDrm_closeSession(AMediaDrm *, const AMediaDrmSessionId &sessionId);
		media_status_t AMediaDrm_closeSession(AMediaDrm , const AMediaDrmSessionId sessionId);

		typedef enum AMediaDrmKeyType {
		/**
		@@ -198,10 +198,10 @@ typedef struct AMediaDrmKeyValuePair {
		* returns MEDIADRM_NOT_PROVISIONED_ERROR if reprovisioning is needed, due to a
		* problem with the device certificate.
		*/
		media_status_t AMediaDrm_getKeyRequest(AMediaDrm *, const AMediaDrmScope &scope,
		media_status_t AMediaDrm_getKeyRequest(AMediaDrm , const AMediaDrmScope scope,
		const uint8_t init, size_t initSize, const char mimeType, AMediaDrmKeyType keyType,
		const AMediaDrmKeyValue *optionalParameters, size_t numOptionalParameters,
		const uint8_t *&keyRequest, size_t &keyRequestSize);
		const uint8_t *keyRequest, size_t keyRequestSize);

		/**
		* A key response is received from the license server by the app, then it is
		@@ -220,8 +220,8 @@ media_status_t AMediaDrm_getKeyRequest(AMediaDrm *, const AMediaDrmScope &scope,
		* responseSize should be set to the size of the response in bytes
		*/

		media_status_t AMediaDrm_provideKeyResponse(AMediaDrm *, const AMediaDrmScope &scope,
		const uint8_t *response, size_t responseSize, AMediaDrmKeySetId &keySetId);
		media_status_t AMediaDrm_provideKeyResponse(AMediaDrm , const AMediaDrmScope scope,
		const uint8_t response, size_t responseSize, AMediaDrmKeySetId keySetId);

		/**
		* Restore persisted offline keys into a new session. keySetId identifies the
		@@ -230,15 +230,15 @@ media_status_t AMediaDrm_provideKeyResponse(AMediaDrm *, const AMediaDrmScope &s
		* sessionId is the session ID for the DRM session
		* keySetId identifies the saved key set to restore
		*/
		media_status_t AMediaDrm_restoreKeys(AMediaDrm *, const AMediaDrmSessionId &sessionId,
		const AMediaDrmKeySetId &keySetId);
		media_status_t AMediaDrm_restoreKeys(AMediaDrm , const AMediaDrmSessionId sessionId,
		const AMediaDrmKeySetId *keySetId);

		/**
		* Remove the current keys from a session.
		*
		* keySetId identifies keys to remove
		*/
		media_status_t AMediaDrm_removeKeys(AMediaDrm *, const AMediaDrmSessionId &keySetId);
		media_status_t AMediaDrm_removeKeys(AMediaDrm , const AMediaDrmSessionId keySetId);

		/**
		* Request an informative description of the key status for the session. The status is
		@@ -253,8 +253,8 @@ media_status_t AMediaDrm_removeKeys(AMediaDrm *, const AMediaDrmSessionId &keySe
		* to be returned is greater than *numPairs, MEDIADRM_SHORT_BUFFER will be returned
		* and numPairs will be set to the number of pairs available.
		*/
		media_status_t AMediaDrm_queryKeyStatus(AMediaDrm *, const AMediaDrmSessionId &sessionId,
		AMediaDrmKeyValue *keyValuePairs, size_t &numPairs);
		media_status_t AMediaDrm_queryKeyStatus(AMediaDrm , const AMediaDrmSessionId sessionId,
		AMediaDrmKeyValue keyValuePairs, size_t numPairs);


		/**
		@@ -272,8 +272,8 @@ media_status_t AMediaDrm_queryKeyStatus(AMediaDrm *, const AMediaDrmSessionId &s
		* the provisioning request should be sent to. It will remain accessible until
		* the next call to getProvisionRequest.
		*/
		media_status_t AMediaDrm_getProvisionRequest(AMediaDrm , const uint8_t &provisionRequest,
		size_t &provisionRequestSize, const char *&serverUrl);
		media_status_t AMediaDrm_getProvisionRequest(AMediaDrm , const uint8_t *provisionRequest,
		size_t provisionRequestSize, const char *serverUrl);


		/**
		@@ -313,7 +313,7 @@ media_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *,
		* number required.
		*/
		media_status_t AMediaDrm_getSecureStops(AMediaDrm *,
		AMediaDrmSecureStop *secureStops, size_t &numSecureStops);
		AMediaDrmSecureStop secureStops, size_t numSecureStops);

		/**
		* Process the SecureStop server response message ssRelease. After authenticating
		@@ -322,7 +322,7 @@ media_status_t AMediaDrm_getSecureStops(AMediaDrm *,
		* ssRelease is the server response indicating which secure stops to release
		*/
		media_status_t AMediaDrm_releaseSecureStops(AMediaDrm *,
		const AMediaDrmSecureStop &ssRelease);
		const AMediaDrmSecureStop *ssRelease);

		/**
		* String property name: identifies the maker of the DRM engine plugin
		@@ -355,7 +355,7 @@ const char *PROPERTY_ALGORITHMS = "algorithms";
		* will remain valid until the next call to AMediaDrm_getPropertyString.
		*/
		media_status_t AMediaDrm_getPropertyString(AMediaDrm , const char propertyName,
		const char *&propertyValue);
		const char **propertyValue);

		/**
		* Byte array property name: the device unique identifier is established during
		@@ -370,7 +370,7 @@ const char *PROPERTY_DEVICE_UNIQUE_ID = "deviceUniqueId";
		* will remain valid until the next call to AMediaDrm_getPropertyByteArray.
		*/
		media_status_t AMediaDrm_getPropertyByteArray(AMediaDrm , const char propertyName,
		AMediaDrmByteArray &propertyValue);
		AMediaDrmByteArray *propertyValue);

		/**
		* Set a DRM engine plugin String property value.
		@@ -409,7 +409,7 @@ media_status_t AMediaDrm_setPropertyByteArray(AMediaDrm , const char propertyN
		* to use is identified by the 16 byte keyId. The key must have been loaded into
		* the session using provideKeyResponse.
		*/
		media_status_t AMediaDrm_encrypt(AMediaDrm *, const AMediaDrmSessionId &sessionId,
		media_status_t AMediaDrm_encrypt(AMediaDrm , const AMediaDrmSessionId sessionId,
		const char cipherAlgorithm, uint8_t keyId, uint8_t *iv,
		const uint8_t input, uint8_t output, size_t dataSize);

		@@ -420,7 +420,7 @@ media_status_t AMediaDrm_encrypt(AMediaDrm *, const AMediaDrmSessionId &sessionI
		* to use is identified by the 16 byte keyId. The key must have been loaded into
		* the session using provideKeyResponse.
		*/
		media_status_t AMediaDrm_decrypt(AMediaDrm *, const AMediaDrmSessionId &sessionId,
		media_status_t AMediaDrm_decrypt(AMediaDrm , const AMediaDrmSessionId sessionId,
		const char cipherAlgorithm, uint8_t keyId, uint8_t *iv,
		const uint8_t input, uint8_t output, size_t dataSize);

		@@ -433,7 +433,7 @@ media_status_t AMediaDrm_decrypt(AMediaDrm *, const AMediaDrmSessionId &sessionI
		* by the 16 byte keyId. The key must have been loaded into the session using
		* provideKeyResponse.
		*/
		media_status_t AMediaDrm_sign(AMediaDrm *, const AMediaDrmSessionId &sessionId,
		media_status_t AMediaDrm_sign(AMediaDrm , const AMediaDrmSessionId sessionId,
		const char macAlgorithm, uint8_t keyId, uint8_t *message, size_t messageSize,
		uint8_t signature, size_t signatureSize);

		@@ -444,7 +444,7 @@ media_status_t AMediaDrm_sign(AMediaDrm *, const AMediaDrmSessionId &sessionId,
		* use is identified by the 16 byte keyId. The key must have been loaded into the
		* session using provideKeyResponse.
		*/
		media_status_t AMediaDrm_verify(AMediaDrm *, const AMediaDrmSessionId &sessionId,
		media_status_t AMediaDrm_verify(AMediaDrm , 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/NdkMediaDrm.cpp

+101 −62

Original line number	Diff line number	Diff line
		@@ -101,7 +101,7 @@ void DrmListener::notify(DrmPlugin::EventType eventType, int extra, const Parcel
		return;
		}

		(*mListener)(mObj, sessionId, ndkEventType, extra, data, dataSize);
		(*mListener)(mObj, &sessionId, ndkEventType, extra, data, dataSize);

		delete [] sessionId.ptr;
		delete [] data;
		@@ -236,29 +236,35 @@ static bool findId(AMediaDrm *mObj, const AMediaDrmByteArray &id, List<idvec_t>:
		}

		EXPORT
		media_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &sessionId) {
		media_status_t AMediaDrm_openSession(AMediaDrm mObj, AMediaDrmSessionId sessionId) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!sessionId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		Vector<uint8_t> session;
		status_t status = mObj->mDrm->openSession(session);
		if (status == OK) {
		mObj->mIds.push_front(session);
		List<idvec_t>::iterator iter = mObj->mIds.begin();
		sessionId.ptr = iter->array();
		sessionId.length = iter->size();
		sessionId->ptr = iter->array();
		sessionId->length = iter->size();
		}
		return AMEDIA_OK;
		}

		EXPORT
		media_status_t AMediaDrm_closeSession(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId) {
		media_status_t AMediaDrm_closeSession(AMediaDrm mObj, const AMediaDrmSessionId sessionId) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!sessionId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}

		List<idvec_t>::iterator iter;
		if (!findId(mObj, sessionId, iter)) {
		if (!findId(mObj, *sessionId, iter)) {
		return AMEDIA_DRM_SESSION_NOT_OPENED;
		}
		mObj->mDrm->closeSession(*iter);
		@@ -267,20 +273,20 @@ media_status_t AMediaDrm_closeSession(AMediaDrm *mObj, const AMediaDrmSessionId
		}

		EXPORT
		media_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope &scope,
		media_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,
		const uint8_t *&keyRequest, size_t &keyRequestSize) {
		const uint8_t *keyRequest, size_t keyRequestSize) {

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!mimeType) {
		if (!mimeType \|\| !scope \|\| !keyRequest \|\| !keyRequestSize) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}

		List<idvec_t>::iterator iter;
		if (!findId(mObj, scope, iter)) {
		if (!findId(mObj, *scope, iter)) {
		return AMEDIA_DRM_SESSION_NOT_OPENED;
		}

		@@ -311,25 +317,25 @@ media_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope &sc
		if (status != OK) {
		return translateStatus(status);
		} else {
		keyRequest = mObj->mKeyRequest.array();
		keyRequestSize = mObj->mKeyRequest.size();
		*keyRequest = mObj->mKeyRequest.array();
		*keyRequestSize = mObj->mKeyRequest.size();
		}
		return AMEDIA_OK;
		}

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

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!response \|\| !responseSize) {
		if (!scope \|\| !response \|\| !responseSize \|\| !keySetId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}

		List<idvec_t>::iterator iter;
		if (!findId(mObj, scope, iter)) {
		if (!findId(mObj, *scope, iter)) {
		return AMEDIA_DRM_SESSION_NOT_OPENED;
		}
		Vector<uint8_t> mdResponse;
		@@ -340,41 +346,47 @@ media_status_t AMediaDrm_provideKeyResponse(AMediaDrm *mObj, const AMediaDrmScop
		if (status == OK) {
		mObj->mIds.push_front(mdKeySetId);
		List<idvec_t>::iterator iter = mObj->mIds.begin();
		keySetId.ptr = iter->array();
		keySetId.length = iter->size();
		keySetId->ptr = iter->array();
		keySetId->length = iter->size();
		} else {
		keySetId.ptr = NULL;
		keySetId.length = 0;
		keySetId->ptr = NULL;
		keySetId->length = 0;
		}
		return AMEDIA_OK;
		}

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

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!sessionId \|\| !keySetId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		List<idvec_t>::iterator iter;
		if (!findId(mObj, sessionId, iter)) {
		if (!findId(mObj, *sessionId, iter)) {
		return AMEDIA_DRM_SESSION_NOT_OPENED;
		}
		Vector<uint8_t> keySet;
		keySet.appendArray(keySetId.ptr, keySetId.length);
		keySet.appendArray(keySetId->ptr, keySetId->length);
		return translateStatus(mObj->mDrm->restoreKeys(*iter, keySet));
		}

		EXPORT
		media_status_t AMediaDrm_removeKeys(AMediaDrm *mObj, const AMediaDrmSessionId &keySetId) {
		media_status_t AMediaDrm_removeKeys(AMediaDrm mObj, const AMediaDrmSessionId keySetId) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!keySetId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		List<idvec_t>::iterator iter;
		status_t status;
		if (!findId(mObj, keySetId, iter)) {
		if (!findId(mObj, *keySetId, iter)) {
		Vector<uint8_t> keySet;
		keySet.appendArray(keySetId.ptr, keySetId.length);
		keySet.appendArray(keySetId->ptr, keySetId->length);
		status = mObj->mDrm->removeKeys(keySet);
		} else {
		status = mObj->mDrm->removeKeys(*iter);
		@@ -384,25 +396,28 @@ media_status_t AMediaDrm_removeKeys(AMediaDrm *mObj, const AMediaDrmSessionId &k
		}

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

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!sessionId \|\| !numPairs) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		List<idvec_t>::iterator iter;
		if (!findId(mObj, sessionId, iter)) {
		if (!findId(mObj, *sessionId, iter)) {
		return AMEDIA_DRM_SESSION_NOT_OPENED;
		}

		status_t status = mObj->mDrm->queryKeyStatus(*iter, mObj->mQueryResults);
		if (status != OK) {
		numPairs = 0;
		*numPairs = 0;
		return translateStatus(status);
		}

		if (mObj->mQueryResults.size() > numPairs) {
		numPairs = mObj->mQueryResults.size();
		if (mObj->mQueryResults.size() > *numPairs) {
		*numPairs = mObj->mQueryResults.size();
		return AMEDIA_DRM_SHORT_BUFFER;
		}

		@@ -410,17 +425,17 @@ media_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessionI
		keyValuePairs[i].mKey = mObj->mQueryResults.keyAt(i).string();
		keyValuePairs[i].mValue = mObj->mQueryResults.keyAt(i).string();
		}
		numPairs = mObj->mQueryResults.size();
		*numPairs = mObj->mQueryResults.size();
		return AMEDIA_OK;
		}

		EXPORT
		media_status_t AMediaDrm_getProvisionRequest(AMediaDrm mObj, const uint8_t &provisionRequest,
		size_t &provisionRequestSize, const char *&serverUrl) {
		media_status_t AMediaDrm_getProvisionRequest(AMediaDrm mObj, const uint8_t *provisionRequest,
		size_t provisionRequestSize, const char *serverUrl) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!provisionRequestSize \|\| !serverUrl) {
		if (!provisionRequest \|\| !provisionRequestSize \|\| !*provisionRequestSize \|\| !serverUrl) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}

		@@ -429,9 +444,9 @@ media_status_t AMediaDrm_getProvisionRequest(AMediaDrm mObj, const uint8_t &pr
		if (status != OK) {
		return translateStatus(status);
		} else {
		provisionRequest = mObj->mProvisionRequest.array();
		provisionRequestSize = mObj->mProvisionRequest.size();
		serverUrl = mObj->mProvisionUrl.string();
		*provisionRequest = mObj->mProvisionRequest.array();
		*provisionRequestSize = mObj->mProvisionRequest.size();
		*serverUrl = mObj->mProvisionUrl.string();
		}
		return AMEDIA_OK;
		}
		@@ -455,17 +470,20 @@ media_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj,

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

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!numSecureStops) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		status_t status = mObj->mDrm->getSecureStops(mObj->mSecureStops);
		if (status != OK) {
		numSecureStops = 0;
		*numSecureStops = 0;
		return translateStatus(status);
		}
		if (numSecureStops < mObj->mSecureStops.size()) {
		if (*numSecureStops < mObj->mSecureStops.size()) {
		return AMEDIA_DRM_SHORT_BUFFER;
		}
		List<Vector<uint8_t> >::iterator iter = mObj->mSecureStops.begin();
		@@ -476,59 +494,68 @@ media_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj,
		++iter;
		++i;
		}
		numSecureStops = mObj->mSecureStops.size();
		*numSecureStops = mObj->mSecureStops.size();
		return AMEDIA_OK;
		}

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

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!ssRelease) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}

		Vector<uint8_t> release;
		release.appendArray(ssRelease.ptr, ssRelease.length);
		release.appendArray(ssRelease->ptr, ssRelease->length);
		return translateStatus(mObj->mDrm->releaseSecureStops(release));
		}


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

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!propertyName \|\| !propertyValue) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}

		status_t status = mObj->mDrm->getPropertyString(String8(propertyName),
		mObj->mPropertyString);

		if (status == OK) {
		propertyValue = mObj->mPropertyString.string();
		*propertyValue = mObj->mPropertyString.string();
		} else {
		propertyValue = NULL;
		*propertyValue = NULL;
		}
		return translateStatus(status);
		}

		EXPORT
		media_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj,
		const char *propertyName, AMediaDrmByteArray &propertyValue) {
		const char propertyName, AMediaDrmByteArray propertyValue) {
		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!propertyName \|\| !propertyValue) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}

		status_t status = mObj->mDrm->getPropertyByteArray(String8(propertyName),
		mObj->mPropertyByteArray);

		if (status == OK) {
		propertyValue.ptr = mObj->mPropertyByteArray.array();
		propertyValue.length = mObj->mPropertyByteArray.size();
		propertyValue->ptr = mObj->mPropertyByteArray.array();
		propertyValue->length = mObj->mPropertyByteArray.size();
		} else {
		propertyValue.ptr = NULL;
		propertyValue.length = 0;
		propertyValue->ptr = NULL;
		propertyValue->length = 0;
		}
		return translateStatus(status);
		}
		@@ -598,31 +625,40 @@ static media_status_t encrypt_decrypt_common(AMediaDrm *mObj,
		}

		EXPORT
		media_status_t AMediaDrm_encrypt(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		media_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) {
		return encrypt_decrypt_common(mObj, sessionId, cipherAlgorithm, keyId, iv,
		if (!sessionId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		return encrypt_decrypt_common(mObj, *sessionId, cipherAlgorithm, keyId, iv,
		input, output, dataSize, true);
		}

		EXPORT
		media_status_t AMediaDrm_decrypt(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		media_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) {
		return encrypt_decrypt_common(mObj, sessionId, cipherAlgorithm, keyId, iv,
		if (!sessionId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		return encrypt_decrypt_common(mObj, *sessionId, cipherAlgorithm, keyId, iv,
		input, output, dataSize, false);
		}

		EXPORT
		media_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		media_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) {

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!sessionId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		List<idvec_t>::iterator iter;
		if (!findId(mObj, sessionId, iter)) {
		if (!findId(mObj, *sessionId, iter)) {
		return AMEDIA_DRM_SESSION_NOT_OPENED;
		}

		@@ -650,15 +686,18 @@ media_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &session
		}

		EXPORT
		media_status_t AMediaDrm_verify(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
		media_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) {

		if (!mObj \|\| mObj->mDrm == NULL) {
		return AMEDIA_ERROR_INVALID_OBJECT;
		}
		if (!sessionId) {
		return AMEDIA_ERROR_INVALID_PARAMETER;
		}
		List<idvec_t>::iterator iter;
		if (!findId(mObj, sessionId, iter)) {
		if (!findId(mObj, *sessionId, iter)) {
		return AMEDIA_DRM_SESSION_NOT_OPENED;
		}