#include <android/native_window.h>
#include "NdkMediaCrypto.h"
+#include "NdkMediaError.h"
#include "NdkMediaFormat.h"
#ifdef __cplusplus
/**
* 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,
* 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
/**
* 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);
/**
/**
* 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);
* 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 {
* 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"
#ifndef _NDK_MEDIA_DRM_H
#define _NDK_MEDIA_DRM_H
+#include <NdkMediaError.h>
+
#ifdef __cplusplus
extern "C" {
#endif
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 {
/**
* 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 {
/**
* 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);
* 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);
/**
* 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);
/**
*
* 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
* 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);
* 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);
* 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);
* 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);
/**
*
* 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);
/**
* 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);
/**
* 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);
/**
* 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);
* 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);
* 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);
* 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);
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
/**
* 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
* 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
#include <sys/types.h>
+#include "NdkMediaError.h"
+
#ifdef __cplusplus
extern "C" {
#endif
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,
#include <sys/types.h>
-#include "NdkMediaFormat.h"
#include "NdkMediaCodec.h"
+#include "NdkMediaError.h"
+#include "NdkMediaFormat.h"
#ifdef __cplusplus
extern "C" {
/**
* 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
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 {
}
EXPORT
-int AMediaCodec_delete(AMediaCodec *mData) {
+media_status_t AMediaCodec_delete(AMediaCodec *mData) {
if (mData->mCodec != NULL) {
mData->mCodec->release();
mData->mCodec.clear();
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,
}
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);
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<AMessage> msg = new AMessage(kWhatStopActivityNotifications, mData->mHandler->id());
sp<AMessage> response;
}
EXPORT
-int AMediaCodec_flush(AMediaCodec *mData) {
+media_status_t AMediaCodec_flush(AMediaCodec *mData) {
return translate_error(mData->mCodec->flush());
}
}
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;
}
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 {
}
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 {
} AMediaCodecCryptoInfo;
EXPORT
-int AMediaCodec_queueSecureInputBuffer(
+media_status_t AMediaCodec_queueSecureInputBuffer(
AMediaCodec* codec,
size_t idx,
off_t offset,
EXPORT
-int AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo* info) {
+media_status_t AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo* info) {
free(info);
- return OK;
+ return AMEDIA_OK;
}
EXPORT
}
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"
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;
}
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;
}
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<uint8_t> session;
status_t status = mObj->mDrm->openSession(session);
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<idvec_t>::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<idvec_t>::iterator iter;
if (!findId(mObj, scope, iter)) {
- return MEDIADRM_SESSION_NOT_OPENED_ERROR;
+ return AMEDIA_DRM_SESSION_NOT_OPENED;
}
Vector<uint8_t> mdInit;
mdKeyType = DrmPlugin::kKeyType_Release;
break;
default:
- return MEDIADRM_INVALID_PARAMETER_ERROR;
+ return AMEDIA_ERROR_INVALID_PARAMETER;
}
KeyedVector<String8, String8> mdOptionalParameters;
for (size_t i = 0; i < numOptionalParameters; i++) {
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<idvec_t>::iterator iter;
if (!findId(mObj, scope, iter)) {
- return MEDIADRM_SESSION_NOT_OPENED_ERROR;
+ return AMEDIA_DRM_SESSION_NOT_OPENED;
}
Vector<uint8_t> mdResponse;
mdResponse.appendArray(response, responseSize);
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<idvec_t>::iterator iter;
if (!findId(mObj, sessionId, iter)) {
- return MEDIADRM_SESSION_NOT_OPENED_ERROR;
+ return AMEDIA_DRM_SESSION_NOT_OPENED;
}
Vector<uint8_t> keySet;
keySet.appendArray(keySetId.ptr, keySetId.length);
}
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<idvec_t>::iterator iter;
status_t status;
}
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<idvec_t>::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);
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++) {
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(""),
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<uint8_t> mdResponse;
}
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) {
return translateStatus(status);
}
if (numSecureStops < mObj->mSecureStops.size()) {
- return MEDIADRM_SHORT_BUFFER;
+ return AMEDIA_DRM_SHORT_BUFFER;
}
List<Vector<uint8_t> >::iterator iter = mObj->mSecureStops.begin();
size_t i = 0;
++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<uint8_t> release;
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),
}
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),
}
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),
}
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<uint8_t> byteArray;
}
-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<idvec_t>::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));
}
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,
}
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,
}
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<idvec_t>::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));
Vector<uint8_t> 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());
}
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<idvec_t>::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));
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);
}
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 {
}
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
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,
if (mediaHttpCreateMethod == NULL) {
ALOGE("can't find method");
env->ExceptionClear();
- return AMEDIAERROR_UNSUPPORTED;
+ return AMEDIA_ERROR_UNSUPPORTED;
}
jstring jloc = env->NewStringUTF(location);
httpService = interface_cast<IMediaHTTPService>(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();
}
}
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));
}
}
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<ABuffer> tmp = new ABuffer(buffer, capacity);
if (mData->mImpl->readSampleData(tmp) == OK) {
}
EXPORT
-int AMediaExtractor_getSampleFlags(AMediaExtractor *mData) {
+uint32_t AMediaExtractor_getSampleFlags(AMediaExtractor *mData) {
int sampleFlags = 0;
sp<MetaData> meta;
status_t err = mData->mImpl->getSampleMeta(&meta);
}
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;
}
}
EXPORT
-int AMediaFormat_delete(AMediaFormat *mData) {
+media_status_t AMediaFormat_delete(AMediaFormat *mData) {
ALOGV("dtor");
delete mData;
- return OK;
+ return AMEDIA_OK;
}
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 {
}
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));
}
}
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<ABuffer> buf = new ABuffer((void*)(data + info.offset), info.size);
return translate_error(
OSDN Git Service
