Only export necessary symbols

Change-Id: I869d7124c8cc555f4b09801a898f4dd3ecb072ec

7 files changed, 114 insertions, 25 deletions

diff --git a/media/ndk/Android.mk b/media/ndk/Android.mk
index 1f155f3..8f795cd 100644
--- a/media/ndk/Android.mk
+++ b/media/ndk/Android.mk
@@ -35,6 +35,8 @@ LOCAL_C_INCLUDES := \
     frameworks/base/core/jni \
     frameworks/av/include/ndk
 
+LOCAL_CFLAGS += -fvisibility=hidden -D EXPORT='__attribute__ ((visibility ("default")))'
+
 LOCAL_SHARED_LIBRARIES := \
     libbinder \
     libmedia \
diff --git a/media/ndk/NdkMediaCodec.cpp b/media/ndk/NdkMediaCodec.cpp
index ac05920..a7c06d5 100644
--- a/media/ndk/NdkMediaCodec.cpp
+++ b/media/ndk/NdkMediaCodec.cpp
@@ -159,19 +159,22 @@ static AMediaCodec * createAMediaCodec(const char *name, bool name_is_type, bool
     return mData;
 }
 
-
+EXPORT
 AMediaCodec* AMediaCodec_createCodecByName(const char *name) {
     return createAMediaCodec(name, false, false);
 }
 
+EXPORT
 AMediaCodec* AMediaCodec_createDecoderByType(const char *mime_type) {
     return createAMediaCodec(mime_type, true, false);
 }
 
+EXPORT
 AMediaCodec* AMediaCodec_createEncoderByType(const char *name) {
     return createAMediaCodec(name, true, true);
 }
 
+EXPORT
 int AMediaCodec_delete(AMediaCodec *mData) {
     if (mData->mCodec != NULL) {
         mData->mCodec->release();
@@ -187,6 +190,7 @@ int AMediaCodec_delete(AMediaCodec *mData) {
     return OK;
 }
 
+EXPORT
 int AMediaCodec_configure(
         AMediaCodec *mData,
         const AMediaFormat* format,
@@ -205,6 +209,7 @@ int AMediaCodec_configure(
             crypto ? crypto->mCrypto : NULL, flags));
 }
 
+EXPORT
 int AMediaCodec_start(AMediaCodec *mData) {
     status_t ret =  mData->mCodec->start();
     if (ret != OK) {
@@ -216,6 +221,7 @@ int AMediaCodec_start(AMediaCodec *mData) {
     return OK;
 }
 
+EXPORT
 int AMediaCodec_stop(AMediaCodec *mData) {
     int ret = translate_error(mData->mCodec->stop());
 
@@ -227,10 +233,12 @@ int AMediaCodec_stop(AMediaCodec *mData) {
     return ret;
 }
 
+EXPORT
 int AMediaCodec_flush(AMediaCodec *mData) {
     return translate_error(mData->mCodec->flush());
 }
 
+EXPORT
 ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec *mData, int64_t timeoutUs) {
     size_t idx;
     status_t ret = mData->mCodec->dequeueInputBuffer(&idx, timeoutUs);
@@ -241,6 +249,7 @@ ssize_t AMediaCodec_dequeueInputBuffer(AMediaCodec *mData, int64_t timeoutUs) {
     return translate_error(ret);
 }
 
+EXPORT
 uint8_t* AMediaCodec_getInputBuffer(AMediaCodec *mData, size_t idx, size_t *out_size) {
     android::Vector<android::sp<android::ABuffer> > abufs;
     if (mData->mCodec->getInputBuffers(&abufs) == 0) {
@@ -258,6 +267,7 @@ uint8_t* AMediaCodec_getInputBuffer(AMediaCodec *mData, size_t idx, size_t *out_
     return NULL;
 }
 
+EXPORT
 uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec *mData, size_t idx, size_t *out_size) {
     android::Vector<android::sp<android::ABuffer> > abufs;
     if (mData->mCodec->getOutputBuffers(&abufs) == 0) {
@@ -275,6 +285,7 @@ uint8_t* AMediaCodec_getOutputBuffer(AMediaCodec *mData, size_t idx, size_t *out
     return NULL;
 }
 
+EXPORT
 int AMediaCodec_queueInputBuffer(AMediaCodec *mData,
         size_t idx, off_t offset, size_t size, uint64_t time, uint32_t flags) {
 
@@ -283,6 +294,7 @@ int AMediaCodec_queueInputBuffer(AMediaCodec *mData,
     return translate_error(ret);
 }
 
+EXPORT
 ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec *mData,
         AMediaCodecBufferInfo *info, int64_t timeoutUs) {
     size_t idx;
@@ -312,12 +324,14 @@ ssize_t AMediaCodec_dequeueOutputBuffer(AMediaCodec *mData,
     return translate_error(ret);
 }
 
+EXPORT
 AMediaFormat* AMediaCodec_getOutputFormat(AMediaCodec *mData) {
     sp<AMessage> format;
     mData->mCodec->getOutputFormat(&format);
     return AMediaFormat_fromMsg(&format);
 }
 
+EXPORT
 int AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render) {
     if (render) {
         return translate_error(mData->mCodec->renderOutputBufferAndRelease(idx));
@@ -326,6 +340,7 @@ int AMediaCodec_releaseOutputBuffer(AMediaCodec *mData, size_t idx, bool render)
     }
 }
 
+EXPORT
 int AMediaCodec_setNotificationCallback(AMediaCodec *mData, OnCodecEvent callback, void *userdata) {
     mData->mCallback = callback;
     mData->mCallbackUserData = userdata;
@@ -341,6 +356,7 @@ typedef struct AMediaCodecCryptoInfo {
         size_t *encryptedbytes;
 } AMediaCodecCryptoInfo;
 
+EXPORT
 int AMediaCodec_queueSecureInputBuffer(
         AMediaCodec* codec,
         size_t idx,
@@ -375,6 +391,7 @@ int AMediaCodec_queueSecureInputBuffer(
 
 
 
+EXPORT
 AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new(
         int numsubsamples,
         uint8_t key[16],
@@ -406,15 +423,18 @@ AMediaCodecCryptoInfo *AMediaCodecCryptoInfo_new(
 }
 
 
+EXPORT
 int AMediaCodecCryptoInfo_delete(AMediaCodecCryptoInfo* info) {
     free(info);
     return OK;
 }
 
+EXPORT
 size_t AMediaCodecCryptoInfo_getNumSubSamples(AMediaCodecCryptoInfo* ci) {
     return ci->numsubsamples;
 }
 
+EXPORT
 int AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
     if (!dst || !ci) {
         return AMEDIAERROR_UNSUPPORTED;
@@ -423,6 +443,7 @@ int AMediaCodecCryptoInfo_getKey(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
     return OK;
 }
 
+EXPORT
 int AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
     if (!dst || !ci) {
         return AMEDIAERROR_UNSUPPORTED;
@@ -431,6 +452,7 @@ int AMediaCodecCryptoInfo_getIV(AMediaCodecCryptoInfo* ci, uint8_t *dst) {
     return OK;
 }
 
+EXPORT
 uint32_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo* ci) {
     if (!ci) {
         return AMEDIAERROR_UNSUPPORTED;
@@ -438,6 +460,7 @@ uint32_t AMediaCodecCryptoInfo_getMode(AMediaCodecCryptoInfo* ci) {
     return ci->mode;
 }
 
+EXPORT
 int AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo* ci, size_t *dst) {
     if (!dst || !ci) {
         return AMEDIAERROR_UNSUPPORTED;
@@ -446,6 +469,7 @@ int AMediaCodecCryptoInfo_getClearBytes(AMediaCodecCryptoInfo* ci, size_t *dst)
     return OK;
 }
 
+EXPORT
 int AMediaCodecCryptoInfo_getEncryptedBytes(AMediaCodecCryptoInfo* ci, size_t *dst) {
     if (!dst || !ci) {
         return AMEDIAERROR_UNSUPPORTED;
diff --git a/media/ndk/NdkMediaCrypto.cpp b/media/ndk/NdkMediaCrypto.cpp
index d57f42b..c686273 100644
--- a/media/ndk/NdkMediaCrypto.cpp
+++ b/media/ndk/NdkMediaCrypto.cpp
@@ -74,6 +74,7 @@ struct AMediaCrypto {
 extern "C" {
 
 
+EXPORT
 bool AMediaCrypto_isCryptoSchemeSupported(const AMediaUUID uuid) {
     sp<ICrypto> crypto = makeCrypto();
     if (crypto == NULL) {
@@ -82,6 +83,7 @@ bool AMediaCrypto_isCryptoSchemeSupported(const AMediaUUID uuid) {
     return crypto->isCryptoSchemeSupported(uuid);
 }
 
+EXPORT
 bool AMediaCrypto_requiresSecureDecoderComponent(const char *mime) {
     sp<ICrypto> crypto = makeCrypto();
     if (crypto == NULL) {
@@ -90,6 +92,7 @@ bool AMediaCrypto_requiresSecureDecoderComponent(const char *mime) {
     return crypto->requiresSecureDecoderComponent(mime);
 }
 
+EXPORT
 AMediaCrypto* AMediaCrypto_new(const AMediaUUID uuid, const void *data, size_t datasize) {
 
     sp<ICrypto> tmp = makeCrypto();
@@ -107,6 +110,7 @@ AMediaCrypto* AMediaCrypto_new(const AMediaUUID uuid, const void *data, size_t d
     return crypto;
 }
 
+EXPORT
 void AMediaCrypto_delete(AMediaCrypto* crypto) {
     delete crypto;
 }
diff --git a/media/ndk/NdkMediaDrm.cpp b/media/ndk/NdkMediaDrm.cpp
index c55cba2..5e50418 100644
--- a/media/ndk/NdkMediaDrm.cpp
+++ b/media/ndk/NdkMediaDrm.cpp
@@ -127,6 +127,7 @@ static sp<IDrm> CreateDrmFromUUID(const AMediaUUID uuid) {
     return drm;
 }
 
+EXPORT
 bool AMediaDrm_isCryptoSchemeSupported(const AMediaUUID uuid, const char *mimeType) {
     sp<IDrm> drm = CreateDrm();
 
@@ -138,12 +139,14 @@ bool AMediaDrm_isCryptoSchemeSupported(const AMediaUUID uuid, const char *mimeTy
     return drm->isCryptoSchemeSupported(uuid, mimeStr);
 }
 
+EXPORT
 AMediaDrm* AMediaDrm_createByUUID(const AMediaUUID uuid) {
     AMediaDrm *mObj = new AMediaDrm();
     mObj->mDrm = CreateDrmFromUUID(uuid);
     return mObj;
 }
 
+EXPORT
 void AMediaDrm_release(AMediaDrm *mObj) {
     if (mObj->mDrm != NULL) {
         mObj->mDrm->setListener(NULL);
@@ -170,6 +173,7 @@ static bool findId(AMediaDrm *mObj, const AMediaDrmByteArray &id, List<idvec_t>:
     return false;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &sessionId) {
     if (!mObj || mObj->mDrm == NULL) {
         return MEDIADRM_INVALID_OBJECT_ERROR;
@@ -185,6 +189,7 @@ mediadrm_status_t AMediaDrm_openSession(AMediaDrm *mObj, AMediaDrmSessionId &ses
     return MEDIADRM_OK;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_closeSession(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId) {
     if (!mObj || mObj->mDrm == NULL) {
         return MEDIADRM_INVALID_OBJECT_ERROR;
@@ -199,6 +204,7 @@ mediadrm_status_t AMediaDrm_closeSession(AMediaDrm *mObj, const AMediaDrmSession
     return MEDIADRM_OK;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope &scope,
         const uint8_t *init, size_t initSize, const char *mimeType, AMediaDrmKeyType keyType,
         const AMediaDrmKeyValue *optionalParameters, size_t numOptionalParameters,
@@ -249,6 +255,7 @@ mediadrm_status_t AMediaDrm_getKeyRequest(AMediaDrm *mObj, const AMediaDrmScope
     return MEDIADRM_OK;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *mObj, const AMediaDrmScope &scope,
         const uint8_t *response, size_t responseSize, AMediaDrmKeySetId &keySetId) {
 
@@ -280,6 +287,7 @@ mediadrm_status_t AMediaDrm_provideKeyResponse(AMediaDrm *mObj, const AMediaDrmS
     return MEDIADRM_OK;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
         const AMediaDrmKeySetId &keySetId) {
 
@@ -295,6 +303,7 @@ mediadrm_status_t AMediaDrm_restoreKeys(AMediaDrm *mObj, const AMediaDrmSessionI
     return translateStatus(mObj->mDrm->restoreKeys(*iter, keySet));
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_removeKeys(AMediaDrm *mObj, const AMediaDrmSessionId &keySetId) {
     if (!mObj || mObj->mDrm == NULL) {
         return MEDIADRM_INVALID_OBJECT_ERROR;
@@ -312,6 +321,7 @@ mediadrm_status_t AMediaDrm_removeKeys(AMediaDrm *mObj, const AMediaDrmSessionId
     return translateStatus(status);
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
         AMediaDrmKeyValue *keyValuePairs, size_t &numPairs) {
 
@@ -342,6 +352,7 @@ mediadrm_status_t AMediaDrm_queryKeyStatus(AMediaDrm *mObj, const AMediaDrmSessi
     return MEDIADRM_OK;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm *mObj, const uint8_t *&provisionRequest,
         size_t &provisionRequestSize, const char *&serverUrl) {
     if (!mObj || mObj->mDrm == NULL) {
@@ -363,6 +374,7 @@ mediadrm_status_t AMediaDrm_getProvisionRequest(AMediaDrm *mObj, const uint8_t *
     return MEDIADRM_OK;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj,
         const uint8_t *response, size_t responseSize) {
     if (!mObj || mObj->mDrm == NULL) {
@@ -379,6 +391,7 @@ mediadrm_status_t AMediaDrm_provideProvisionResponse(AMediaDrm *mObj,
     return translateStatus(mObj->mDrm->provideProvisionResponse(mdResponse, unused, unused));
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj,
         AMediaDrmSecureStop *secureStops, size_t &numSecureStops) {
 
@@ -405,6 +418,7 @@ mediadrm_status_t AMediaDrm_getSecureStops(AMediaDrm *mObj,
     return MEDIADRM_OK;
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_releaseSecureStops(AMediaDrm *mObj,
         const AMediaDrmSecureStop &ssRelease) {
 
@@ -418,6 +432,7 @@ mediadrm_status_t AMediaDrm_releaseSecureStops(AMediaDrm *mObj,
 }
 
 
+EXPORT
 mediadrm_status_t AMediaDrm_getPropertyString(AMediaDrm *mObj, const char *propertyName,
         const char *&propertyValue) {
 
@@ -436,6 +451,7 @@ mediadrm_status_t AMediaDrm_getPropertyString(AMediaDrm *mObj, const char *prope
     return translateStatus(status);
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj,
         const char *propertyName, AMediaDrmByteArray &propertyValue) {
     if (!mObj || mObj->mDrm == NULL) {
@@ -455,6 +471,7 @@ mediadrm_status_t AMediaDrm_getPropertyByteArray(AMediaDrm *mObj,
     return translateStatus(status);
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_setPropertyString(AMediaDrm *mObj,
         const char *propertyName, const char *value) {
     if (!mObj || mObj->mDrm == NULL) {
@@ -465,6 +482,7 @@ mediadrm_status_t AMediaDrm_setPropertyString(AMediaDrm *mObj,
                     String8(value)));
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_setPropertyByteArray(AMediaDrm *mObj,
         const char *propertyName, const uint8_t *value, size_t valueSize) {
 
@@ -517,6 +535,7 @@ static mediadrm_status_t encrypt_decrypt_common(AMediaDrm *mObj,
     return translateStatus(status);
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_encrypt(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
         const char *cipherAlgorithm, uint8_t *keyId, uint8_t *iv,
         const uint8_t *input, uint8_t *output, size_t dataSize) {
@@ -524,6 +543,7 @@ mediadrm_status_t AMediaDrm_encrypt(AMediaDrm *mObj, const AMediaDrmSessionId &s
             input, output, dataSize, true);
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_decrypt(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
         const char *cipherAlgorithm, uint8_t *keyId, uint8_t *iv,
         const uint8_t *input, uint8_t *output, size_t dataSize) {
@@ -531,6 +551,7 @@ mediadrm_status_t AMediaDrm_decrypt(AMediaDrm *mObj, const AMediaDrmSessionId &s
             input, output, dataSize, false);
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
         const char *macAlgorithm, uint8_t *keyId, uint8_t *message, size_t messageSize,
         uint8_t *signature, size_t *signatureSize) {
@@ -566,6 +587,7 @@ mediadrm_status_t AMediaDrm_sign(AMediaDrm *mObj, const AMediaDrmSessionId &sess
     return translateStatus(status);
 }
 
+EXPORT
 mediadrm_status_t AMediaDrm_verify(AMediaDrm *mObj, const AMediaDrmSessionId &sessionId,
         const char *macAlgorithm, uint8_t *keyId, const uint8_t *message, size_t messageSize,
         const uint8_t *signature, size_t signatureSize) {
diff --git a/media/ndk/NdkMediaExtractor.cpp b/media/ndk/NdkMediaExtractor.cpp
index 0a66988..e23adf3 100644
--- a/media/ndk/NdkMediaExtractor.cpp
+++ b/media/ndk/NdkMediaExtractor.cpp
@@ -54,6 +54,7 @@ struct AMediaExtractor {
 
 extern "C" {
 
+EXPORT
 AMediaExtractor* AMediaExtractor_new() {
     ALOGV("ctor");
     AMediaExtractor *mData = new AMediaExtractor();
@@ -61,18 +62,21 @@ AMediaExtractor* AMediaExtractor_new() {
     return mData;
 }
 
+EXPORT
 int AMediaExtractor_delete(AMediaExtractor *mData) {
     ALOGV("dtor");
     delete mData;
     return OK;
 }
 
+EXPORT
 int AMediaExtractor_setDataSourceFd(AMediaExtractor *mData, int fd, off64_t offset, off64_t length) {
     ALOGV("setDataSource(%d, %lld, %lld)", fd, offset, length);
     mData->mImpl->setDataSource(fd, offset, length);
     return 0;
 }
 
+EXPORT
 int AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location) {
     ALOGV("setDataSource(%s)", location);
     // TODO: add header support
@@ -116,31 +120,37 @@ int AMediaExtractor_setDataSource(AMediaExtractor *mData, const char *location)
     return OK;
 }
 
+EXPORT
 int AMediaExtractor_getTrackCount(AMediaExtractor *mData) {
     return mData->mImpl->countTracks();
 }
 
+EXPORT
 AMediaFormat* AMediaExtractor_getTrackFormat(AMediaExtractor *mData, size_t idx) {
     sp<AMessage> format;
     mData->mImpl->getTrackFormat(idx, &format);
     return AMediaFormat_fromMsg(&format);
 }
 
+EXPORT
 int AMediaExtractor_selectTrack(AMediaExtractor *mData, size_t idx) {
     ALOGV("selectTrack(%z)", idx);
     return translate_error(mData->mImpl->selectTrack(idx));
 }
 
+EXPORT
 int AMediaExtractor_unselectTrack(AMediaExtractor *mData, size_t idx) {
     ALOGV("unselectTrack(%z)", idx);
     return translate_error(mData->mImpl->unselectTrack(idx));
 }
 
+EXPORT
 bool AMediaExtractor_advance(AMediaExtractor *mData) {
     //ALOGV("advance");
     return mData->mImpl->advance();
 }
 
+EXPORT
 int AMediaExtractor_readSampleData(AMediaExtractor *mData, uint8_t *buffer, size_t capacity) {
     //ALOGV("readSampleData");
     sp<ABuffer> tmp = new ABuffer(buffer, capacity);
@@ -150,6 +160,7 @@ int AMediaExtractor_readSampleData(AMediaExtractor *mData, uint8_t *buffer, size
     return -1;
 }
 
+EXPORT
 int AMediaExtractor_getSampleFlags(AMediaExtractor *mData) {
     int sampleFlags = 0;
     sp<MetaData> meta;
@@ -171,6 +182,7 @@ int AMediaExtractor_getSampleFlags(AMediaExtractor *mData) {
     return sampleFlags;
 }
 
+EXPORT
 int AMediaExtractor_getSampleTrackIndex(AMediaExtractor *mData) {
     size_t idx;
     if (mData->mImpl->getSampleTrackIndex(&idx) != OK) {
@@ -179,6 +191,7 @@ int AMediaExtractor_getSampleTrackIndex(AMediaExtractor *mData) {
     return idx;
 }
 
+EXPORT
 int64_t AMediaExtractor_getSampletime(AMediaExtractor *mData) {
     int64_t time;
     if (mData->mImpl->getSampleTime(&time) != OK) {
@@ -187,6 +200,7 @@ int64_t AMediaExtractor_getSampletime(AMediaExtractor *mData) {
     return time;
 }
 
+EXPORT
 PsshInfo* AMediaExtractor_getPsshInfo(AMediaExtractor *ex) {
 
     if (ex->mPsshBuf != NULL) {
@@ -267,6 +281,7 @@ PsshInfo* AMediaExtractor_getPsshInfo(AMediaExtractor *ex) {
     return (PsshInfo*) ex->mPsshBuf->data();
 }
 
+EXPORT
 AMediaCodecCryptoInfo *AMediaExtractor_getSampleCryptoInfo(AMediaExtractor *ex) {
     sp<MetaData> meta;
     if(ex->mImpl->getSampleMeta(&meta) != 0) {
diff --git a/media/ndk/NdkMediaFormat.cpp b/media/ndk/NdkMediaFormat.cpp
index c08814f..e1d8c95 100644
--- a/media/ndk/NdkMediaFormat.cpp
+++ b/media/ndk/NdkMediaFormat.cpp
@@ -56,12 +56,14 @@ void AMediaFormat_getFormat(const AMediaFormat* mData, void* dest) {
 /*
  * public function follow
  */
+EXPORT
 AMediaFormat *AMediaFormat_new() {
     ALOGV("ctor");
     sp<AMessage> msg = new AMessage();
     return AMediaFormat_fromMsg(&msg);
 }
 
+EXPORT
 int AMediaFormat_delete(AMediaFormat *mData) {
     ALOGV("dtor");
     delete mData;
@@ -69,6 +71,7 @@ int AMediaFormat_delete(AMediaFormat *mData) {
 }
 
 
+EXPORT
 const char* AMediaFormat_toString(AMediaFormat *mData) {
     sp<AMessage> f = mData->mFormat;
     String8 ret;
@@ -141,22 +144,27 @@ const char* AMediaFormat_toString(AMediaFormat *mData) {
     return mData->mDebug.string();
 }
 
+EXPORT
 bool AMediaFormat_getInt32(AMediaFormat* format, const char *name, int32_t *out) {
     return format->mFormat->findInt32(name, out);
 }
 
+EXPORT
 bool AMediaFormat_getInt64(AMediaFormat* format, const char *name, int64_t *out) {
     return format->mFormat->findInt64(name, out);
 }
 
+EXPORT
 bool AMediaFormat_getFloat(AMediaFormat* format, const char *name, float *out) {
     return format->mFormat->findFloat(name, out);
 }
 
+EXPORT
 bool AMediaFormat_getSize(AMediaFormat* format, const char *name, size_t *out) {
     return format->mFormat->findSize(name, out);
 }
 
+EXPORT
 bool AMediaFormat_getBuffer(AMediaFormat* format, const char *name, void** data, size_t *outsize) {
     sp<ABuffer> buf;
     if (format->mFormat->findBuffer(name, &buf)) {
@@ -167,6 +175,7 @@ bool AMediaFormat_getBuffer(AMediaFormat* format, const char *name, void** data,
     return false;
 }
 
+EXPORT
 bool AMediaFormat_getString(AMediaFormat* mData, const char *name, const char **out) {
 
     for (size_t i = 0; i < mData->mStringCache.size(); i++) {
@@ -186,23 +195,28 @@ bool AMediaFormat_getString(AMediaFormat* mData, const char *name, const char **
     return false;
 }
 
+EXPORT
 void AMediaFormat_setInt32(AMediaFormat* format, const char *name, int32_t value) {
     format->mFormat->setInt32(name, value);
 }
 
+EXPORT
 void AMediaFormat_setInt64(AMediaFormat* format, const char *name, int64_t value) {
     format->mFormat->setInt64(name, value);
 }
 
+EXPORT
 void AMediaFormat_setFloat(AMediaFormat* format, const char* name, float value) {
     format->mFormat->setFloat(name, value);
 }
 
+EXPORT
 void AMediaFormat_setString(AMediaFormat* format, const char* name, const char* value) {
     // AMessage::setString() makes a copy of the string
     format->mFormat->setString(name, value, strlen(value));
 }
 
+EXPORT
 void AMediaFormat_setBuffer(AMediaFormat* format, const char* name, void* data, size_t size) {
     // the ABuffer(void*, size_t) constructor doesn't take ownership of the data, so create
     // a new buffer and copy the data into it
@@ -214,30 +228,30 @@ void AMediaFormat_setBuffer(AMediaFormat* format, const char* name, void* data,
 }
 
 
-const char* AMEDIAFORMAT_KEY_AAC_PROFILE = "aac-profile";
-const char* AMEDIAFORMAT_KEY_BIT_RATE = "bitrate";
-const char* AMEDIAFORMAT_KEY_CHANNEL_COUNT = "channel-count";
-const char* AMEDIAFORMAT_KEY_CHANNEL_MASK = "channel-mask";
-const char* AMEDIAFORMAT_KEY_COLOR_FORMAT = "color-format";
-const char* AMEDIAFORMAT_KEY_DURATION = "durationUs";
-const char* AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL = "flac-compression-level";
-const char* AMEDIAFORMAT_KEY_FRAME_RATE = "frame-rate";
-const char* AMEDIAFORMAT_KEY_HEIGHT = "height";
-const char* AMEDIAFORMAT_KEY_IS_ADTS = "is-adts";
-const char* AMEDIAFORMAT_KEY_IS_AUTOSELECT = "is-autoselect";
-const char* AMEDIAFORMAT_KEY_IS_DEFAULT = "is-default";
-const char* AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE = "is-forced-subtitle";
-const char* AMEDIAFORMAT_KEY_I_FRAME_INTERVAL = "i-frame-interval";
-const char* AMEDIAFORMAT_KEY_LANGUAGE = "language";
-const char* AMEDIAFORMAT_KEY_MAX_HEIGHT = "max-height";
-const char* AMEDIAFORMAT_KEY_MAX_INPUT_SIZE = "max-input-size";
-const char* AMEDIAFORMAT_KEY_MAX_WIDTH = "max-width";
-const char* AMEDIAFORMAT_KEY_MIME = "mime";
-const char* AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP = "push-blank-buffers-on-shutdown";
-const char* AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER = "repeat-previous-frame-after";
-const char* AMEDIAFORMAT_KEY_SAMPLE_RATE = "sample-rate";
-const char* AMEDIAFORMAT_KEY_WIDTH = "width";
-const char* AMEDIAFORMAT_KEY_STRIDE = "stride";
+EXPORT const char* AMEDIAFORMAT_KEY_AAC_PROFILE = "aac-profile";
+EXPORT const char* AMEDIAFORMAT_KEY_BIT_RATE = "bitrate";
+EXPORT const char* AMEDIAFORMAT_KEY_CHANNEL_COUNT = "channel-count";
+EXPORT const char* AMEDIAFORMAT_KEY_CHANNEL_MASK = "channel-mask";
+EXPORT const char* AMEDIAFORMAT_KEY_COLOR_FORMAT = "color-format";
+EXPORT const char* AMEDIAFORMAT_KEY_DURATION = "durationUs";
+EXPORT const char* AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL = "flac-compression-level";
+EXPORT const char* AMEDIAFORMAT_KEY_FRAME_RATE = "frame-rate";
+EXPORT const char* AMEDIAFORMAT_KEY_HEIGHT = "height";
+EXPORT const char* AMEDIAFORMAT_KEY_IS_ADTS = "is-adts";
+EXPORT const char* AMEDIAFORMAT_KEY_IS_AUTOSELECT = "is-autoselect";
+EXPORT const char* AMEDIAFORMAT_KEY_IS_DEFAULT = "is-default";
+EXPORT const char* AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE = "is-forced-subtitle";
+EXPORT const char* AMEDIAFORMAT_KEY_I_FRAME_INTERVAL = "i-frame-interval";
+EXPORT const char* AMEDIAFORMAT_KEY_LANGUAGE = "language";
+EXPORT const char* AMEDIAFORMAT_KEY_MAX_HEIGHT = "max-height";
+EXPORT const char* AMEDIAFORMAT_KEY_MAX_INPUT_SIZE = "max-input-size";
+EXPORT const char* AMEDIAFORMAT_KEY_MAX_WIDTH = "max-width";
+EXPORT const char* AMEDIAFORMAT_KEY_MIME = "mime";
+EXPORT const char* AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP = "push-blank-buffers-on-shutdown";
+EXPORT const char* AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER = "repeat-previous-frame-after";
+EXPORT const char* AMEDIAFORMAT_KEY_SAMPLE_RATE = "sample-rate";
+EXPORT const char* AMEDIAFORMAT_KEY_WIDTH = "width";
+EXPORT const char* AMEDIAFORMAT_KEY_STRIDE = "stride";
 
 
 } // extern "C"
diff --git a/media/ndk/NdkMediaMuxer.cpp b/media/ndk/NdkMediaMuxer.cpp
index 98129cb..aa78740 100644
--- a/media/ndk/NdkMediaMuxer.cpp
+++ b/media/ndk/NdkMediaMuxer.cpp
@@ -52,6 +52,7 @@ struct AMediaMuxer {
 
 extern "C" {
 
+EXPORT
 AMediaMuxer* AMediaMuxer_new(int fd, OutputFormat format) {
     ALOGV("ctor");
     AMediaMuxer *mData = new AMediaMuxer();
@@ -59,34 +60,41 @@ AMediaMuxer* AMediaMuxer_new(int fd, OutputFormat format) {
     return mData;
 }
 
+EXPORT
 int AMediaMuxer_delete(AMediaMuxer *muxer) {
     ALOGV("dtor");
     delete muxer;
     return OK;
 }
 
+EXPORT
 int 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) {
     return translate_error(muxer->mImpl->setOrientationHint(degrees));
 }
 
+EXPORT
 ssize_t AMediaMuxer_addTrack(AMediaMuxer *muxer, const AMediaFormat *format) {
     sp<AMessage> msg;
     AMediaFormat_getFormat(format, &msg);
     return translate_error(muxer->mImpl->addTrack(msg));
 }
 
+EXPORT
 int AMediaMuxer_start(AMediaMuxer *muxer) {
     return translate_error(muxer->mImpl->start());
 }
 
+EXPORT
 int AMediaMuxer_stop(AMediaMuxer *muxer) {
     return translate_error(muxer->mImpl->stop());
 }
 
+EXPORT
 int 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);