From e419d7cd5c62b4b5866a45d59c5770bb470193c1 Mon Sep 17 00:00:00 2001 From: Marco Nelissen Date: Thu, 15 May 2014 14:17:25 -0700 Subject: Unify error/status codes Change-Id: Ib90cc2f2adc07ff146256931c92c0ec4becb86f5 --- include/ndk/NdkMediaCodec.h | 30 +++++---- include/ndk/NdkMediaDrm.h | 57 ++++++---------- include/ndk/NdkMediaError.h | 29 ++++++-- include/ndk/NdkMediaExtractor.h | 16 ++--- include/ndk/NdkMediaFormat.h | 4 +- include/ndk/NdkMediaMuxer.h | 15 +++-- media/ndk/NdkMediaCodec.cpp | 84 +++++++++++++---------- media/ndk/NdkMediaCrypto.cpp | 6 +- media/ndk/NdkMediaDrm.cpp | 145 ++++++++++++++++++++-------------------- media/ndk/NdkMediaExtractor.cpp | 41 ++++++------ media/ndk/NdkMediaFormat.cpp | 4 +- media/ndk/NdkMediaMuxer.cpp | 20 +++--- 12 files changed, 233 insertions(+), 218 deletions(-) diff --git a/include/ndk/NdkMediaCodec.h b/include/ndk/NdkMediaCodec.h index 28d121c..dd869f6 100644 --- a/include/ndk/NdkMediaCodec.h +++ b/include/ndk/NdkMediaCodec.h @@ -30,6 +30,7 @@ #include #include "NdkMediaCrypto.h" +#include "NdkMediaError.h" #include "NdkMediaFormat.h" #ifdef __cplusplus @@ -78,12 +79,12 @@ AMediaCodec* AMediaCodec_createEncoderByType(const char *mime_type); /** * delete the codec and free its resources */ -int AMediaCodec_delete(AMediaCodec*); +media_status_t AMediaCodec_delete(AMediaCodec*); /** * Configure the codec. For decoding you would typically get the format from an extractor. */ -int AMediaCodec_configure( +media_status_t AMediaCodec_configure( AMediaCodec*, const AMediaFormat* format, ANativeWindow* surface, @@ -94,18 +95,18 @@ int AMediaCodec_configure( * Start the codec. A codec must be configured before it can be started, and must be started * before buffers can be sent to it. */ -int AMediaCodec_start(AMediaCodec*); +media_status_t AMediaCodec_start(AMediaCodec*); /** * Stop the codec. */ -int AMediaCodec_stop(AMediaCodec*); +media_status_t AMediaCodec_stop(AMediaCodec*); /* * Flush the codec's input and output. All indices previously returned from calls to * AMediaCodec_dequeueInputBuffer and AMediaCodec_dequeueOutputBuffer become invalid. */ -int AMediaCodec_flush(AMediaCodec*); +media_status_t AMediaCodec_flush(AMediaCodec*); /** * Get an input buffer. The specified buffer index must have been previously obtained from @@ -129,13 +130,13 @@ ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec*, int64_t timeoutUs); /** * Send the specified buffer to the codec for processing. */ -int AMediaCodec_queueInputBuffer(AMediaCodec*, +media_status_t AMediaCodec_queueInputBuffer(AMediaCodec*, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags); /** * Send the specified buffer to the codec for processing. */ -int AMediaCodec_queueSecureInputBuffer(AMediaCodec*, +media_status_t AMediaCodec_queueSecureInputBuffer(AMediaCodec*, size_t idx, off_t offset, AMediaCodecCryptoInfo*, uint64_t time, uint32_t flags); /** @@ -147,7 +148,7 @@ AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec*); /** * Release and optionally render the specified buffer. */ -int AMediaCodec_releaseOutputBuffer(AMediaCodec*, size_t idx, bool render); +media_status_t AMediaCodec_releaseOutputBuffer(AMediaCodec*, size_t idx, bool render); typedef void (*OnCodecEvent)(AMediaCodec *codec, void *userdata); @@ -158,7 +159,8 @@ typedef void (*OnCodecEvent)(AMediaCodec *codec, void *userdata); * Note that you cannot perform any operations on the mediacodec from within the callback. * If you need to perform mediacodec operations, you must do so on a different thread. */ -int AMediaCodec_setNotificationCallback(AMediaCodec*, OnCodecEvent callback, void *userdata); +media_status_t AMediaCodec_setNotificationCallback( + AMediaCodec*, OnCodecEvent callback, void *userdata); enum { @@ -182,14 +184,14 @@ AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new( * delete an AMediaCodecCryptoInfo created previously with AMediaCodecCryptoInfo_new, or * obtained from AMediaExtractor */ -int AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo*); +media_status_t AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo*); size_t AMediaCodecCryptoInfo_getNumSubSamples(AMediaCodecCryptoInfo*); -int AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo*, uint8_t *dst); -int AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo*, uint8_t *dst); +media_status_t AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo*, uint8_t *dst); +media_status_t AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo*, uint8_t *dst); uint32_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo*); -int AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo*, size_t *dst); -int AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo*, size_t *dst); +media_status_t AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo*, size_t *dst); +media_status_t AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo*, size_t *dst); #ifdef __cplusplus } // extern "C" diff --git a/include/ndk/NdkMediaDrm.h b/include/ndk/NdkMediaDrm.h index 1322a9d..6eaab66 100644 --- a/include/ndk/NdkMediaDrm.h +++ b/include/ndk/NdkMediaDrm.h @@ -27,6 +27,8 @@ #ifndef _NDK_MEDIA_DRM_H #define _NDK_MEDIA_DRM_H +#include + #ifdef __cplusplus extern "C" { #endif @@ -47,23 +49,6 @@ typedef AMediaDrmByteArray AMediaDrmScope; typedef AMediaDrmByteArray AMediaDrmKeySetId; typedef AMediaDrmByteArray AMediaDrmSecureStop; -#define MEDIADRM_ERROR_BASE -2000 - -typedef enum { - MEDIADRM_OK = 0, - MEDIADRM_NOT_PROVISIONED_ERROR = MEDIADRM_ERROR_BASE - 1, - MEDIADRM_RESOURCE_BUSY_ERROR = MEDIADRM_ERROR_BASE - 2, - MEDIADRM_DEVICE_REVOKED_ERROR = MEDIADRM_ERROR_BASE - 3, - MEDIADRM_SHORT_BUFFER = MEDIADRM_ERROR_BASE - 4, - MEDIADRM_INVALID_OBJECT_ERROR = MEDIADRM_ERROR_BASE - 5, - MEDIADRM_INVALID_PARAMETER_ERROR = MEDIADRM_ERROR_BASE - 6, - MEDIADRM_SESSION_NOT_OPENED_ERROR = MEDIADRM_ERROR_BASE - 7, - MEDIADRM_TAMPER_DETECTED_ERROR = MEDIADRM_ERROR_BASE - 8, - MEDIADRM_VERIFY_FAILED = MEDIADRM_ERROR_BASE - 9, - MEDIADRM_NEED_KEY_ERROR = MEDIADRM_ERROR_BASE - 10, - MEDIADRM_LICENSE_EXPIRED_ERROR = MEDIADRM_ERROR_BASE - 11, - MEDIADRM_UNKNOWN_ERROR = MEDIADRM_ERROR_BASE - 12, -} mediadrm_status_t; typedef enum AMediaDrmEventType { /** @@ -130,13 +115,13 @@ void AMediaDrm_setOnEventListener(AMediaDrm *, AMediaDrmEventListener listener); * returns MEDIADRM_NOT_PROVISIONED_ERROR if provisioning is needed * returns MEDIADRM_RESOURCE_BUSY_ERROR if required resources are in use */ -mediadrm_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. */ -mediadrm_status_t AMediaDrm_closeSession(AMediaDrm *, const AMediaDrmSessionId &sessionId); +media_status_t AMediaDrm_closeSession(AMediaDrm *, const AMediaDrmSessionId &sessionId); typedef enum AMediaDrmKeyType { /** @@ -213,7 +198,7 @@ typedef struct AMediaDrmKeyValuePair { * returns MEDIADRM_NOT_PROVISIONED_ERROR if reprovisioning is needed, due to a * problem with the device certificate. */ -mediadrm_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); @@ -235,7 +220,7 @@ mediadrm_status_t AMediaDrm_getKeyRequest(AMediaDrm *, const AMediaDrmScope &sco * responseSize should be set to the size of the response in bytes */ -mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *, const AMediaDrmScope &scope, +media_status_t AMediaDrm_provideKeyResponse(AMediaDrm *, const AMediaDrmScope &scope, const uint8_t *response, size_t responseSize, AMediaDrmKeySetId &keySetId); /** @@ -245,7 +230,7 @@ mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *, const AMediaDrmScope * sessionId is the session ID for the DRM session * keySetId identifies the saved key set to restore */ -mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *, const AMediaDrmSessionId &sessionId, +media_status_t AMediaDrm_restoreKeys(AMediaDrm *, const AMediaDrmSessionId &sessionId, const AMediaDrmKeySetId &keySetId); /** @@ -253,7 +238,7 @@ mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *, const AMediaDrmSessionId &s * * keySetId identifies keys to remove */ -mediadrm_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 @@ -268,7 +253,7 @@ mediadrm_status_t AMediaDrm_removeKeys(AMediaDrm *, const AMediaDrmSessionId &ke * to be returned is greater than *numPairs, MEDIADRM_SHORT_BUFFER will be returned * and numPairs will be set to the number of pairs available. */ -mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *, const AMediaDrmSessionId &sessionId, +media_status_t AMediaDrm_queryKeyStatus(AMediaDrm *, const AMediaDrmSessionId &sessionId, AMediaDrmKeyValue *keyValuePairs, size_t &numPairs); @@ -287,7 +272,7 @@ mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *, const AMediaDrmSessionId * the provisioning request should be sent to. It will remain accessible until * the next call to getProvisionRequest. */ -mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm *, const uint8_t *&provisionRequest, +media_status_t AMediaDrm_getProvisionRequest(AMediaDrm *, const uint8_t *&provisionRequest, size_t &provisionRequestSize, const char *&serverUrl); @@ -302,7 +287,7 @@ mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm *, const uint8_t *&pro * returns MEDIADRM_DEVICE_REVOKED_ERROR if the response indicates that the * server rejected the request */ -mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *, +media_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *, const uint8_t *response, size_t responseSize); @@ -327,7 +312,7 @@ mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *, * MEDIADRM_SHORT_BUFFER will be returned and *numSecureStops will be set to the * number required. */ -mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *, +media_status_t AMediaDrm_getSecureStops(AMediaDrm *, AMediaDrmSecureStop *secureStops, size_t &numSecureStops); /** @@ -336,7 +321,7 @@ mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *, * * ssRelease is the server response indicating which secure stops to release */ -mediadrm_status_t AMediaDrm_releaseSecureStops(AMediaDrm *, +media_status_t AMediaDrm_releaseSecureStops(AMediaDrm *, const AMediaDrmSecureStop &ssRelease); /** @@ -369,7 +354,7 @@ const char *PROPERTY_ALGORITHMS = "algorithms"; * memory that the value resides in is owned by the NDK MediaDrm API and * will remain valid until the next call to AMediaDrm_getPropertyString. */ -mediadrm_status_t AMediaDrm_getPropertyString(AMediaDrm *, const char *propertyName, +media_status_t AMediaDrm_getPropertyString(AMediaDrm *, const char *propertyName, const char *&propertyValue); /** @@ -384,19 +369,19 @@ const char *PROPERTY_DEVICE_UNIQUE_ID = "deviceUniqueId"; * memory that the value resides in is owned by the NDK MediaDrm API and * will remain valid until the next call to AMediaDrm_getPropertyByteArray. */ -mediadrm_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *, const char *propertyName, +media_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *, const char *propertyName, AMediaDrmByteArray &propertyValue); /** * Set a DRM engine plugin String property value. */ -mediadrm_status_t AMediaDrm_setPropertyString(AMediaDrm *, const char *propertyName, +media_status_t AMediaDrm_setPropertyString(AMediaDrm *, const char *propertyName, const char *value); /** * Set a DRM engine plugin byte array property value. */ -mediadrm_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *, const char *propertyName, +media_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *, const char *propertyName, const uint8_t *value, size_t valueSize); /** @@ -424,7 +409,7 @@ mediadrm_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *, const char *proper * to use is identified by the 16 byte keyId. The key must have been loaded into * the session using provideKeyResponse. */ -mediadrm_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); @@ -435,7 +420,7 @@ mediadrm_status_t AMediaDrm_encrypt(AMediaDrm *, const AMediaDrmSessionId &sessi * to use is identified by the 16 byte keyId. The key must have been loaded into * the session using provideKeyResponse. */ -mediadrm_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); @@ -448,7 +433,7 @@ mediadrm_status_t AMediaDrm_decrypt(AMediaDrm *, const AMediaDrmSessionId &sessi * by the 16 byte keyId. The key must have been loaded into the session using * provideKeyResponse. */ -mediadrm_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); @@ -459,7 +444,7 @@ mediadrm_status_t AMediaDrm_sign(AMediaDrm *, const AMediaDrmSessionId &sessionI * use is identified by the 16 byte keyId. The key must have been loaded into the * session using provideKeyResponse. */ -mediadrm_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); diff --git a/include/ndk/NdkMediaError.h b/include/ndk/NdkMediaError.h index b89a10e..12613eb 100644 --- a/include/ndk/NdkMediaError.h +++ b/include/ndk/NdkMediaError.h @@ -32,13 +32,28 @@ extern "C" { #endif -enum { - AMEDIAERROR_BASE = -10000, - - AMEDIAERROR_GENERIC = AMEDIAERROR_BASE, - AMEDIAERROR_MALFORMED = AMEDIAERROR_BASE - 1, - AMEDIAERROR_UNSUPPORTED = AMEDIAERROR_BASE - 2 -}; +typedef enum { + AMEDIA_OK = 0, + + AMEDIA_ERROR_BASE = -10000, + AMEDIA_ERROR_UNKNOWN = AMEDIA_ERROR_BASE, + AMEDIA_ERROR_MALFORMED = AMEDIA_ERROR_BASE - 1, + AMEDIA_ERROR_UNSUPPORTED = AMEDIA_ERROR_BASE - 2, + AMEDIA_ERROR_INVALID_OBJECT = AMEDIA_ERROR_BASE - 3, + AMEDIA_ERROR_INVALID_PARAMETER = AMEDIA_ERROR_BASE - 4, + + AMEDIA_DRM_ERROR_BASE = -20000, + AMEDIA_DRM_NOT_PROVISIONED = AMEDIA_DRM_ERROR_BASE - 1, + AMEDIA_DRM_RESOURCE_BUSY = AMEDIA_DRM_ERROR_BASE - 2, + AMEDIA_DRM_DEVICE_REVOKED = AMEDIA_DRM_ERROR_BASE - 3, + AMEDIA_DRM_SHORT_BUFFER = AMEDIA_DRM_ERROR_BASE - 4, + AMEDIA_DRM_SESSION_NOT_OPENED = AMEDIA_DRM_ERROR_BASE - 5, + AMEDIA_DRM_TAMPER_DETECTED = AMEDIA_DRM_ERROR_BASE - 6, + AMEDIA_DRM_VERIFY_FAILED = AMEDIA_DRM_ERROR_BASE - 7, + AMEDIA_DRM_NEED_KEY = AMEDIA_DRM_ERROR_BASE - 8, + AMEDIA_DRM_LICENSE_EXPIRED = AMEDIA_DRM_ERROR_BASE - 9, + +} media_status_t; #ifdef __cplusplus diff --git a/include/ndk/NdkMediaExtractor.h b/include/ndk/NdkMediaExtractor.h index 9e50ec0..2ba69fb 100644 --- a/include/ndk/NdkMediaExtractor.h +++ b/include/ndk/NdkMediaExtractor.h @@ -50,22 +50,22 @@ AMediaExtractor* AMediaExtractor_new(); /** * Delete a previously created media extractor */ -int AMediaExtractor_delete(AMediaExtractor*); +media_status_t AMediaExtractor_delete(AMediaExtractor*); /** * Set the file descriptor from which the extractor will read. */ -int AMediaExtractor_setDataSourceFd(AMediaExtractor*, int fd, off64_t offset, off64_t length); +media_status_t AMediaExtractor_setDataSourceFd(AMediaExtractor*, int fd, off64_t offset, off64_t length); /** * Set the URI from which the extractor will read. */ -int AMediaExtractor_setDataSource(AMediaExtractor*, const char *location); // TODO support headers +media_status_t AMediaExtractor_setDataSource(AMediaExtractor*, const char *location); // TODO support headers /** * Return the number of tracks in the previously specified media file */ -int AMediaExtractor_getTrackCount(AMediaExtractor*); +size_t AMediaExtractor_getTrackCount(AMediaExtractor*); /** * Return the format of the specified track. The caller must free the returned format @@ -78,23 +78,23 @@ AMediaFormat* AMediaExtractor_getTrackFormat(AMediaExtractor*, size_t idx); * Selecting the same track multiple times has no effect, the track is * only selected once. */ -int AMediaExtractor_selectTrack(AMediaExtractor*, size_t idx); +media_status_t AMediaExtractor_selectTrack(AMediaExtractor*, size_t idx); /** * Unselect the specified track. Subsequent calls to readSampleData, getSampleTrackIndex and * getSampleTime only retrieve information for the subset of tracks selected.. */ -int AMediaExtractor_unselectTrack(AMediaExtractor*, size_t idx); +media_status_t AMediaExtractor_unselectTrack(AMediaExtractor*, size_t idx); /** * Read the current sample. */ -int AMediaExtractor_readSampleData(AMediaExtractor*, uint8_t *buffer, size_t capacity); +ssize_t AMediaExtractor_readSampleData(AMediaExtractor*, uint8_t *buffer, size_t capacity); /** * Read the current sample's flags. */ -int AMediaExtractor_getSampleFlags(AMediaExtractor*); // see definitions below +uint32_t AMediaExtractor_getSampleFlags(AMediaExtractor*); // see definitions below /** * Returns the track index the current sample originates from (or -1 diff --git a/include/ndk/NdkMediaFormat.h b/include/ndk/NdkMediaFormat.h index e0caeab..ab29791 100644 --- a/include/ndk/NdkMediaFormat.h +++ b/include/ndk/NdkMediaFormat.h @@ -29,6 +29,8 @@ #include +#include "NdkMediaError.h" + #ifdef __cplusplus extern "C" { #endif @@ -37,7 +39,7 @@ struct AMediaFormat; typedef struct AMediaFormat AMediaFormat; AMediaFormat *AMediaFormat_new(); -int AMediaFormat_delete(AMediaFormat*); +media_status_t AMediaFormat_delete(AMediaFormat*); /** * Human readable representation of the format. The returned string is owned by the format, diff --git a/include/ndk/NdkMediaMuxer.h b/include/ndk/NdkMediaMuxer.h index deb150d..db183e9 100644 --- a/include/ndk/NdkMediaMuxer.h +++ b/include/ndk/NdkMediaMuxer.h @@ -30,8 +30,9 @@ #include -#include "NdkMediaFormat.h" #include "NdkMediaCodec.h" +#include "NdkMediaError.h" +#include "NdkMediaFormat.h" #ifdef __cplusplus extern "C" { @@ -53,19 +54,19 @@ AMediaMuxer* AMediaMuxer_new(int fd, OutputFormat format); /** * Delete a previously created media muxer */ -int AMediaMuxer_delete(AMediaMuxer*); +media_status_t AMediaMuxer_delete(AMediaMuxer*); -int AMediaMuxer_setLocation(AMediaMuxer*, float latitude, float longtitude); +media_status_t AMediaMuxer_setLocation(AMediaMuxer*, float latitude, float longtitude); -int AMediaMuxer_setOrientationHint(AMediaMuxer*, int degrees); +media_status_t AMediaMuxer_setOrientationHint(AMediaMuxer*, int degrees); ssize_t AMediaMuxer_addTrack(AMediaMuxer*, const AMediaFormat* format); -int AMediaMuxer_start(AMediaMuxer*); +media_status_t AMediaMuxer_start(AMediaMuxer*); -int AMediaMuxer_stop(AMediaMuxer*); +media_status_t AMediaMuxer_stop(AMediaMuxer*); -int AMediaMuxer_writeSampleData(AMediaMuxer *muxer, +media_status_t AMediaMuxer_writeSampleData(AMediaMuxer *muxer, size_t trackIdx, const uint8_t *data, const AMediaCodecBufferInfo &info); #ifdef __cplusplus diff --git a/media/ndk/NdkMediaCodec.cpp b/media/ndk/NdkMediaCodec.cpp index a7c06d5..9e2aa67 100644 --- a/media/ndk/NdkMediaCodec.cpp +++ b/media/ndk/NdkMediaCodec.cpp @@ -36,14 +36,14 @@ using namespace android; -static int translate_error(status_t err) { +static media_status_t translate_error(status_t err) { if (err == OK) { - return OK; + return AMEDIA_OK; } else if (err == -EAGAIN) { - return AMEDIACODEC_INFO_TRY_AGAIN_LATER; + return (media_status_t) AMEDIACODEC_INFO_TRY_AGAIN_LATER; } ALOGE("sf error code: %d", err); - return AMEDIAERROR_GENERIC; + return AMEDIA_ERROR_UNKNOWN; } enum { @@ -175,7 +175,7 @@ AMediaCodec* AMediaCodec_createEncoderByType(const char *name) { } EXPORT -int AMediaCodec_delete(AMediaCodec *mData) { +media_status_t AMediaCodec_delete(AMediaCodec *mData) { if (mData->mCodec != NULL) { mData->mCodec->release(); mData->mCodec.clear(); @@ -187,11 +187,11 @@ int AMediaCodec_delete(AMediaCodec *mData) { mData->mLooper.clear(); } delete mData; - return OK; + return AMEDIA_OK; } EXPORT -int AMediaCodec_configure( +media_status_t AMediaCodec_configure( AMediaCodec *mData, const AMediaFormat* format, ANativeWindow* window, @@ -210,7 +210,7 @@ int AMediaCodec_configure( } EXPORT -int AMediaCodec_start(AMediaCodec *mData) { +media_status_t AMediaCodec_start(AMediaCodec *mData) { status_t ret = mData->mCodec->start(); if (ret != OK) { return translate_error(ret); @@ -218,12 +218,12 @@ int AMediaCodec_start(AMediaCodec *mData) { mData->mActivityNotification = new AMessage(kWhatActivityNotify, mData->mHandler->id()); mData->mActivityNotification->setInt32("generation", mData->mGeneration); requestActivityNotification(mData); - return OK; + return AMEDIA_OK; } EXPORT -int AMediaCodec_stop(AMediaCodec *mData) { - int ret = translate_error(mData->mCodec->stop()); +media_status_t AMediaCodec_stop(AMediaCodec *mData) { + media_status_t ret = translate_error(mData->mCodec->stop()); sp msg = new AMessage(kWhatStopActivityNotifications, mData->mHandler->id()); sp response; @@ -234,7 +234,7 @@ int AMediaCodec_stop(AMediaCodec *mData) { } EXPORT -int AMediaCodec_flush(AMediaCodec *mData) { +media_status_t AMediaCodec_flush(AMediaCodec *mData) { return translate_error(mData->mCodec->flush()); } @@ -286,7 +286,7 @@ uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec *mData, size_t idx, size_t *out } EXPORT -int AMediaCodec_queueInputBuffer(AMediaCodec *mData, +media_status_t AMediaCodec_queueInputBuffer(AMediaCodec *mData, size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags) { AString errorMsg; @@ -332,7 +332,7 @@ AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec *mData) { } EXPORT -int AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render) { +media_status_t AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render) { if (render) { return translate_error(mData->mCodec->renderOutputBufferAndRelease(idx)); } else { @@ -341,10 +341,10 @@ int AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render) } EXPORT -int AMediaCodec_setNotificationCallback(AMediaCodec *mData, OnCodecEvent callback, void *userdata) { +media_status_t AMediaCodec_setNotificationCallback(AMediaCodec *mData, OnCodecEvent callback, void *userdata) { mData->mCallback = callback; mData->mCallbackUserData = userdata; - return OK; + return AMEDIA_OK; } typedef struct AMediaCodecCryptoInfo { @@ -357,7 +357,7 @@ typedef struct AMediaCodecCryptoInfo { } AMediaCodecCryptoInfo; EXPORT -int AMediaCodec_queueSecureInputBuffer( +media_status_t AMediaCodec_queueSecureInputBuffer( AMediaCodec* codec, size_t idx, off_t offset, @@ -424,9 +424,9 @@ AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new( EXPORT -int AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo* info) { +media_status_t AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo* info) { free(info); - return OK; + return AMEDIA_OK; } EXPORT @@ -435,47 +435,59 @@ size_t AMediaCodecCryptoInfo_getNumSubSamples(AMediaCodecCryptoInfo* ci) { } EXPORT -int AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo* ci, uint8_t *dst) { - if (!dst || !ci) { - return AMEDIAERROR_UNSUPPORTED; +media_status_t AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo* ci, uint8_t *dst) { + if (!ci) { + return AMEDIA_ERROR_INVALID_OBJECT; + } + if (!dst) { + return AMEDIA_ERROR_INVALID_PARAMETER; } memcpy(dst, ci->key, 16); - return OK; + return AMEDIA_OK; } EXPORT -int AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo* ci, uint8_t *dst) { - if (!dst || !ci) { - return AMEDIAERROR_UNSUPPORTED; +media_status_t AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo* ci, uint8_t *dst) { + if (!ci) { + return AMEDIA_ERROR_INVALID_OBJECT; + } + if (!dst) { + return AMEDIA_ERROR_INVALID_PARAMETER; } memcpy(dst, ci->iv, 16); - return OK; + return AMEDIA_OK; } EXPORT uint32_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo* ci) { if (!ci) { - return AMEDIAERROR_UNSUPPORTED; + return AMEDIA_ERROR_INVALID_OBJECT; } return ci->mode; } EXPORT -int AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo* ci, size_t *dst) { - if (!dst || !ci) { - return AMEDIAERROR_UNSUPPORTED; +media_status_t AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo* ci, size_t *dst) { + if (!ci) { + return AMEDIA_ERROR_INVALID_OBJECT; + } + if (!dst) { + return AMEDIA_ERROR_INVALID_PARAMETER; } memcpy(dst, ci->clearbytes, sizeof(size_t) * ci->numsubsamples); - return OK; + return AMEDIA_OK; } EXPORT -int AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo* ci, size_t *dst) { - if (!dst || !ci) { - return AMEDIAERROR_UNSUPPORTED; +media_status_t AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo* ci, size_t *dst) { + if (!ci) { + return AMEDIA_ERROR_INVALID_OBJECT; + } + if (!dst) { + return AMEDIA_ERROR_INVALID_PARAMETER; } memcpy(dst, ci->encryptedbytes, sizeof(size_t) * ci->numsubsamples); - return OK; + return AMEDIA_OK; } } // extern "C" diff --git a/media/ndk/NdkMediaCrypto.cpp b/media/ndk/NdkMediaCrypto.cpp index c686273..cbadea5 100644 --- a/media/ndk/NdkMediaCrypto.cpp +++ b/media/ndk/NdkMediaCrypto.cpp @@ -35,12 +35,12 @@ using namespace android; -static int translate_error(status_t err) { +static media_status_t translate_error(status_t err) { if (err == OK) { - return OK; + return AMEDIA_OK; } ALOGE("sf error code: %d", err); - return -1000; + return AMEDIA_ERROR_UNKNOWN; } diff --git a/media/ndk/NdkMediaDrm.cpp b/media/ndk/NdkMediaDrm.cpp index 5e50418..2f068be 100644 --- a/media/ndk/NdkMediaDrm.cpp +++ b/media/ndk/NdkMediaDrm.cpp @@ -51,38 +51,37 @@ struct AMediaDrm { extern "C" { -static mediadrm_status_t translateStatus(status_t status) { - mediadrm_status_t result = MEDIADRM_UNKNOWN_ERROR; +static media_status_t translateStatus(status_t status) { + media_status_t result = AMEDIA_ERROR_UNKNOWN; switch (status) { case OK: - result = MEDIADRM_OK; + result = AMEDIA_OK; break; case android::ERROR_DRM_NOT_PROVISIONED: - result = MEDIADRM_NOT_PROVISIONED_ERROR; + result = AMEDIA_DRM_NOT_PROVISIONED; break; case android::ERROR_DRM_RESOURCE_BUSY: - result = MEDIADRM_RESOURCE_BUSY_ERROR; + result = AMEDIA_DRM_RESOURCE_BUSY; break; case android::ERROR_DRM_DEVICE_REVOKED: - result = MEDIADRM_DEVICE_REVOKED_ERROR; + result = AMEDIA_DRM_DEVICE_REVOKED; break; case android::ERROR_DRM_CANNOT_HANDLE: - result = MEDIADRM_INVALID_PARAMETER_ERROR; + result = AMEDIA_ERROR_INVALID_PARAMETER; break; case android::ERROR_DRM_TAMPER_DETECTED: - result = MEDIADRM_TAMPER_DETECTED_ERROR; + result = AMEDIA_DRM_TAMPER_DETECTED; break; case android::ERROR_DRM_SESSION_NOT_OPENED: - result = MEDIADRM_SESSION_NOT_OPENED_ERROR; + result = AMEDIA_DRM_SESSION_NOT_OPENED; break; case android::ERROR_DRM_NO_LICENSE: - result = MEDIADRM_NEED_KEY_ERROR; + result = AMEDIA_DRM_NEED_KEY; break; case android::ERROR_DRM_LICENSE_EXPIRED: - result = MEDIADRM_LICENSE_EXPIRED_ERROR; + result = AMEDIA_DRM_LICENSE_EXPIRED; break; default: - result = MEDIADRM_UNKNOWN_ERROR; break; } return result; @@ -174,9 +173,9 @@ static bool findId(AMediaDrm *mObj, const AMediaDrmByteArray &id, List: } EXPORT -mediadrm_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &sessionId) { +media_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &sessionId) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } Vector session; status_t status = mObj->mDrm->openSession(session); @@ -186,40 +185,40 @@ mediadrm_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &ses sessionId.ptr = iter->array(); sessionId.length = iter->size(); } - return MEDIADRM_OK; + return AMEDIA_OK; } EXPORT -mediadrm_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 MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } List::iterator iter; if (!findId(mObj, sessionId, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } mObj->mDrm->closeSession(*iter); mObj->mIds.erase(iter); - return MEDIADRM_OK; + return AMEDIA_OK; } EXPORT -mediadrm_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) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } if (!mimeType) { - return MEDIADRM_INVALID_PARAMETER_ERROR; + return AMEDIA_ERROR_INVALID_PARAMETER; } List::iterator iter; if (!findId(mObj, scope, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } Vector mdInit; @@ -236,7 +235,7 @@ mediadrm_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope mdKeyType = DrmPlugin::kKeyType_Release; break; default: - return MEDIADRM_INVALID_PARAMETER_ERROR; + return AMEDIA_ERROR_INVALID_PARAMETER; } KeyedVector mdOptionalParameters; for (size_t i = 0; i < numOptionalParameters; i++) { @@ -252,23 +251,23 @@ mediadrm_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope keyRequest = mObj->mKeyRequest.array(); keyRequestSize = mObj->mKeyRequest.size(); } - return MEDIADRM_OK; + return AMEDIA_OK; } EXPORT -mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *mObj, const AMediaDrmScope &scope, +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 MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } if (!response || !responseSize) { - return MEDIADRM_INVALID_PARAMETER_ERROR; + return AMEDIA_ERROR_INVALID_PARAMETER; } List::iterator iter; if (!findId(mObj, scope, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } Vector mdResponse; mdResponse.appendArray(response, responseSize); @@ -284,19 +283,19 @@ mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *mObj, const AMediaDrmS keySetId.ptr = NULL; keySetId.length = 0; } - return MEDIADRM_OK; + return AMEDIA_OK; } EXPORT -mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId, +media_status_t AMediaDrm_restoreKeys(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId, const AMediaDrmKeySetId &keySetId) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } List::iterator iter; if (!findId(mObj, sessionId, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } Vector keySet; keySet.appendArray(keySetId.ptr, keySetId.length); @@ -304,9 +303,9 @@ mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *mObj, const AMediaDrmSessionI } EXPORT -mediadrm_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 MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } List::iterator iter; status_t status; @@ -322,15 +321,15 @@ mediadrm_status_t AMediaDrm_removeKeys(AMediaDrm *mObj, const AMediaDrmSessionId } EXPORT -mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId, +media_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId, AMediaDrmKeyValue *keyValuePairs, size_t &numPairs) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } List::iterator iter; if (!findId(mObj, sessionId, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } status_t status = mObj->mDrm->queryKeyStatus(*iter, mObj->mQueryResults); @@ -341,7 +340,7 @@ mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessi if (mObj->mQueryResults.size() > numPairs) { numPairs = mObj->mQueryResults.size(); - return MEDIADRM_SHORT_BUFFER; + return AMEDIA_DRM_SHORT_BUFFER; } for (size_t i = 0; i < mObj->mQueryResults.size(); i++) { @@ -349,17 +348,17 @@ mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessi keyValuePairs[i].mValue = mObj->mQueryResults.keyAt(i).string(); } numPairs = mObj->mQueryResults.size(); - return MEDIADRM_OK; + return AMEDIA_OK; } EXPORT -mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm *mObj, const uint8_t *&provisionRequest, +media_status_t AMediaDrm_getProvisionRequest(AMediaDrm *mObj, const uint8_t *&provisionRequest, size_t &provisionRequestSize, const char *&serverUrl) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } if (!provisionRequestSize || !serverUrl) { - return MEDIADRM_INVALID_PARAMETER_ERROR; + return AMEDIA_ERROR_INVALID_PARAMETER; } status_t status = mObj->mDrm->getProvisionRequest(String8(""), String8(""), @@ -371,17 +370,17 @@ mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm *mObj, const uint8_t * provisionRequestSize = mObj->mProvisionRequest.size(); serverUrl = mObj->mProvisionUrl.string(); } - return MEDIADRM_OK; + return AMEDIA_OK; } EXPORT -mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj, +media_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj, const uint8_t *response, size_t responseSize) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } if (!response || !responseSize) { - return MEDIADRM_INVALID_PARAMETER_ERROR; + return AMEDIA_ERROR_INVALID_PARAMETER; } Vector mdResponse; @@ -392,11 +391,11 @@ mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj, } EXPORT -mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj, +media_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj, AMediaDrmSecureStop *secureStops, size_t &numSecureStops) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } status_t status = mObj->mDrm->getSecureStops(mObj->mSecureStops); if (status != OK) { @@ -404,7 +403,7 @@ mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj, return translateStatus(status); } if (numSecureStops < mObj->mSecureStops.size()) { - return MEDIADRM_SHORT_BUFFER; + return AMEDIA_DRM_SHORT_BUFFER; } List >::iterator iter = mObj->mSecureStops.begin(); size_t i = 0; @@ -415,15 +414,15 @@ mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj, ++i; } numSecureStops = mObj->mSecureStops.size(); - return MEDIADRM_OK; + return AMEDIA_OK; } EXPORT -mediadrm_status_t AMediaDrm_releaseSecureStops(AMediaDrm *mObj, +media_status_t AMediaDrm_releaseSecureStops(AMediaDrm *mObj, const AMediaDrmSecureStop &ssRelease) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } Vector release; @@ -433,11 +432,11 @@ mediadrm_status_t AMediaDrm_releaseSecureStops(AMediaDrm *mObj, EXPORT -mediadrm_status_t AMediaDrm_getPropertyString(AMediaDrm *mObj, const char *propertyName, +media_status_t AMediaDrm_getPropertyString(AMediaDrm *mObj, const char *propertyName, const char *&propertyValue) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } status_t status = mObj->mDrm->getPropertyString(String8(propertyName), @@ -452,10 +451,10 @@ mediadrm_status_t AMediaDrm_getPropertyString(AMediaDrm *mObj, const char *prope } EXPORT -mediadrm_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj, +media_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj, const char *propertyName, AMediaDrmByteArray &propertyValue) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } status_t status = mObj->mDrm->getPropertyByteArray(String8(propertyName), @@ -472,10 +471,10 @@ mediadrm_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj, } EXPORT -mediadrm_status_t AMediaDrm_setPropertyString(AMediaDrm *mObj, +media_status_t AMediaDrm_setPropertyString(AMediaDrm *mObj, const char *propertyName, const char *value) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } return translateStatus(mObj->mDrm->setPropertyString(String8(propertyName), @@ -483,7 +482,7 @@ mediadrm_status_t AMediaDrm_setPropertyString(AMediaDrm *mObj, } EXPORT -mediadrm_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *mObj, +media_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *mObj, const char *propertyName, const uint8_t *value, size_t valueSize) { Vector byteArray; @@ -494,17 +493,17 @@ mediadrm_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *mObj, } -static mediadrm_status_t encrypt_decrypt_common(AMediaDrm *mObj, +static media_status_t encrypt_decrypt_common(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId, const char *cipherAlgorithm, uint8_t *keyId, uint8_t *iv, const uint8_t *input, uint8_t *output, size_t dataSize, bool encrypt) { if (!mObj || mObj->mDrm == NULL) { - return MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } List::iterator iter; if (!findId(mObj, sessionId, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } status_t status = mObj->mDrm->setCipherAlgorithm(*iter, String8(cipherAlgorithm)); @@ -536,7 +535,7 @@ static mediadrm_status_t encrypt_decrypt_common(AMediaDrm *mObj, } EXPORT -mediadrm_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, @@ -544,7 +543,7 @@ mediadrm_status_t AMediaDrm_encrypt(AMediaDrm *mObj, const AMediaDrmSessionId &s } EXPORT -mediadrm_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, @@ -552,16 +551,16 @@ mediadrm_status_t AMediaDrm_decrypt(AMediaDrm *mObj, const AMediaDrmSessionId &s } EXPORT -mediadrm_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 MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } List::iterator iter; if (!findId(mObj, sessionId, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } status_t status = mObj->mDrm->setMacAlgorithm(*iter, String8(macAlgorithm)); @@ -579,7 +578,7 @@ mediadrm_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &sess Vector signatureVec; status = mObj->mDrm->sign(*iter, keyIdVec, messageVec, signatureVec); if (signatureVec.size() > *signatureSize) { - return MEDIADRM_SHORT_BUFFER; + return AMEDIA_DRM_SHORT_BUFFER; } if (status == OK) { memcpy(signature, signatureVec.array(), signatureVec.size()); @@ -588,16 +587,16 @@ mediadrm_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &sess } EXPORT -mediadrm_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 MEDIADRM_INVALID_OBJECT_ERROR; + return AMEDIA_ERROR_INVALID_OBJECT; } List::iterator iter; if (!findId(mObj, sessionId, iter)) { - return MEDIADRM_SESSION_NOT_OPENED_ERROR; + return AMEDIA_DRM_SESSION_NOT_OPENED; } status_t status = mObj->mDrm->setMacAlgorithm(*iter, String8(macAlgorithm)); @@ -618,7 +617,7 @@ mediadrm_status_t AMediaDrm_verify(AMediaDrm *mObj, const AMediaDrmSessionId &se bool match; status = mObj->mDrm->verify(*iter, keyIdVec, messageVec, signatureVec, match); if (status == OK) { - return match ? MEDIADRM_OK : MEDIADRM_VERIFY_FAILED; + return match ? AMEDIA_OK : AMEDIA_DRM_VERIFY_FAILED; } return translateStatus(status); } diff --git a/media/ndk/NdkMediaExtractor.cpp b/media/ndk/NdkMediaExtractor.cpp index e23adf3..563358f 100644 --- a/media/ndk/NdkMediaExtractor.cpp +++ b/media/ndk/NdkMediaExtractor.cpp @@ -38,12 +38,12 @@ using namespace android; -static int translate_error(status_t err) { +static media_status_t translate_error(status_t err) { if (err == OK) { - return OK; + return AMEDIA_OK; } ALOGE("sf error code: %d", err); - return AMEDIAERROR_GENERIC; + return AMEDIA_ERROR_UNKNOWN; } struct AMediaExtractor { @@ -63,21 +63,20 @@ AMediaExtractor* AMediaExtractor_new() { } EXPORT -int AMediaExtractor_delete(AMediaExtractor *mData) { +media_status_t AMediaExtractor_delete(AMediaExtractor *mData) { ALOGV("dtor"); delete mData; - return OK; + return AMEDIA_OK; } EXPORT -int AMediaExtractor_setDataSourceFd(AMediaExtractor *mData, int fd, off64_t offset, off64_t length) { +media_status_t 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; + return translate_error(mData->mImpl->setDataSource(fd, offset, length)); } EXPORT -int AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location) { +media_status_t AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location) { ALOGV("setDataSource(%s)", location); // TODO: add header support @@ -86,14 +85,14 @@ int AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location) if (env == NULL) { ALOGE("setDataSource(path) must be called from Java thread"); env->ExceptionClear(); - return AMEDIAERROR_UNSUPPORTED; + return AMEDIA_ERROR_UNSUPPORTED; } jclass mediahttpclass = env->FindClass("android/media/MediaHTTPService"); if (mediahttpclass == NULL) { ALOGE("can't find MediaHttpService"); env->ExceptionClear(); - return AMEDIAERROR_UNSUPPORTED; + return AMEDIA_ERROR_UNSUPPORTED; } jmethodID mediaHttpCreateMethod = env->GetStaticMethodID(mediahttpclass, @@ -101,7 +100,7 @@ int AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location) if (mediaHttpCreateMethod == NULL) { ALOGE("can't find method"); env->ExceptionClear(); - return AMEDIAERROR_UNSUPPORTED; + return AMEDIA_ERROR_UNSUPPORTED; } jstring jloc = env->NewStringUTF(location); @@ -115,13 +114,13 @@ int AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location) httpService = interface_cast(binder); } - mData->mImpl->setDataSource(httpService, location, NULL); + status_t err = mData->mImpl->setDataSource(httpService, location, NULL); env->ExceptionClear(); - return OK; + return translate_error(err); } EXPORT -int AMediaExtractor_getTrackCount(AMediaExtractor *mData) { +size_t AMediaExtractor_getTrackCount(AMediaExtractor *mData) { return mData->mImpl->countTracks(); } @@ -133,13 +132,13 @@ AMediaFormat* AMediaExtractor_getTrackFormat(AMediaExtractor *mData, size_t idx) } EXPORT -int AMediaExtractor_selectTrack(AMediaExtractor *mData, size_t idx) { +media_status_t 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) { +media_status_t AMediaExtractor_unselectTrack(AMediaExtractor *mData, size_t idx) { ALOGV("unselectTrack(%z)", idx); return translate_error(mData->mImpl->unselectTrack(idx)); } @@ -151,7 +150,7 @@ bool AMediaExtractor_advance(AMediaExtractor *mData) { } EXPORT -int AMediaExtractor_readSampleData(AMediaExtractor *mData, uint8_t *buffer, size_t capacity) { +ssize_t AMediaExtractor_readSampleData(AMediaExtractor *mData, uint8_t *buffer, size_t capacity) { //ALOGV("readSampleData"); sp tmp = new ABuffer(buffer, capacity); if (mData->mImpl->readSampleData(tmp) == OK) { @@ -161,7 +160,7 @@ int AMediaExtractor_readSampleData(AMediaExtractor *mData, uint8_t *buffer, size } EXPORT -int AMediaExtractor_getSampleFlags(AMediaExtractor *mData) { +uint32_t AMediaExtractor_getSampleFlags(AMediaExtractor *mData) { int sampleFlags = 0; sp meta; status_t err = mData->mImpl->getSampleMeta(&meta); @@ -170,14 +169,14 @@ int AMediaExtractor_getSampleFlags(AMediaExtractor *mData) { } int32_t val; if (meta->findInt32(kKeyIsSyncFrame, &val) && val != 0) { - sampleFlags |= NuMediaExtractor::SAMPLE_FLAG_SYNC; + sampleFlags |= AMEDIAEXTRACTOR_SAMPLE_FLAG_SYNC; } uint32_t type; const void *data; size_t size; if (meta->findData(kKeyEncryptedSizes, &type, &data, &size)) { - sampleFlags |= NuMediaExtractor::SAMPLE_FLAG_ENCRYPTED; + sampleFlags |= AMEDIAEXTRACTOR_SAMPLE_FLAG_ENCRYPTED; } return sampleFlags; } diff --git a/media/ndk/NdkMediaFormat.cpp b/media/ndk/NdkMediaFormat.cpp index e1d8c95..77018ec 100644 --- a/media/ndk/NdkMediaFormat.cpp +++ b/media/ndk/NdkMediaFormat.cpp @@ -64,10 +64,10 @@ AMediaFormat *AMediaFormat_new() { } EXPORT -int AMediaFormat_delete(AMediaFormat *mData) { +media_status_t AMediaFormat_delete(AMediaFormat *mData) { ALOGV("dtor"); delete mData; - return OK; + return AMEDIA_OK; } diff --git a/media/ndk/NdkMediaMuxer.cpp b/media/ndk/NdkMediaMuxer.cpp index aa78740..19b9fc4 100644 --- a/media/ndk/NdkMediaMuxer.cpp +++ b/media/ndk/NdkMediaMuxer.cpp @@ -37,12 +37,12 @@ using namespace android; -static int translate_error(status_t err) { +static media_status_t translate_error(status_t err) { if (err == OK) { - return OK; + return AMEDIA_OK; } ALOGE("sf error code: %d", err); - return -1000; + return AMEDIA_ERROR_UNKNOWN; } struct AMediaMuxer { @@ -61,19 +61,19 @@ AMediaMuxer* AMediaMuxer_new(int fd, OutputFormat format) { } EXPORT -int AMediaMuxer_delete(AMediaMuxer *muxer) { +media_status_t AMediaMuxer_delete(AMediaMuxer *muxer) { ALOGV("dtor"); delete muxer; - return OK; + return AMEDIA_OK; } EXPORT -int AMediaMuxer_setLocation(AMediaMuxer *muxer, float latitude, float longtitude) { +media_status_t AMediaMuxer_setLocation(AMediaMuxer *muxer, float latitude, float longtitude) { return translate_error(muxer->mImpl->setLocation(latitude * 10000, longtitude * 10000)); } EXPORT -int AMediaMuxer_setOrientationHint(AMediaMuxer *muxer, int degrees) { +media_status_t AMediaMuxer_setOrientationHint(AMediaMuxer *muxer, int degrees) { return translate_error(muxer->mImpl->setOrientationHint(degrees)); } @@ -85,17 +85,17 @@ ssize_t AMediaMuxer_addTrack(AMediaMuxer *muxer, const AMediaFormat *format) { } EXPORT -int AMediaMuxer_start(AMediaMuxer *muxer) { +media_status_t AMediaMuxer_start(AMediaMuxer *muxer) { return translate_error(muxer->mImpl->start()); } EXPORT -int AMediaMuxer_stop(AMediaMuxer *muxer) { +media_status_t AMediaMuxer_stop(AMediaMuxer *muxer) { return translate_error(muxer->mImpl->stop()); } EXPORT -int AMediaMuxer_writeSampleData(AMediaMuxer *muxer, +media_status_t AMediaMuxer_writeSampleData(AMediaMuxer *muxer, size_t trackIdx, const uint8_t *data, const AMediaCodecBufferInfo &info) { sp buf = new ABuffer((void*)(data + info.offset), info.size); return translate_error( -- cgit v1.1