Port to q-x86

diff --git a/extractor/Android.mk b/extractor/Android.mk
index 69e450f..c41ece0 100644 (file)
--- a/extractor/Android.mk
+++ b/extractor/Android.mk
@@ -7,9 +7,9 @@ LOCAL_SRC_FILES := \
 
 LOCAL_SHARED_LIBRARIES += \
        libbinder         \
-       libmediaextractor \
        libffmpeg_utils   \
-       liblog            \
+       libmediandk       \
+       liblog
 
 LOCAL_MODULE:= libffmpeg_extractor
 LOCAL_MODULE_RELATIVE_PATH := extractors

diff --git a/extractor/FFmpegExtractor.cpp b/extractor/FFmpegExtractor.cpp
index bc0ca57..1e9ce65 100644 (file)
--- a/extractor/FFmpegExtractor.cpp
+++ b/extractor/FFmpegExtractor.cpp
@@ -26,8 +26,7 @@
 #include <utils/misc.h>
 #include <utils/String8.h>
 #include <cutils/properties.h>
-#include <media/DataSource.h>
-#include <media/MediaSource.h>
+#include <media/DataSourceBase.h>
 #include <media/stagefright/foundation/ABitReader.h>
 #include <media/stagefright/foundation/ABuffer.h>
 #include <media/stagefright/foundation/ADebug.h>
@@ -38,7 +37,6 @@
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/MediaDefs.h>
 #include <media/stagefright/MediaErrors.h>
-#include <media/stagefright/MetaData.h>
 #include <media/stagefright/Utils.h>
 
 #include "utils/codec_utils.h"
@@ -71,17 +69,17 @@ enum {
 namespace android {
 
 static const char *findMatchingContainer(const char *name);
-static MediaExtractor *CreateFFMPEGExtractor(DataSourceBase *source, void *meta);
+static CMediaExtractor *CreateFFMPEGExtractor(CDataSource *source, void *meta);
 
-struct FFmpegSource : public MediaTrack {
+struct FFmpegSource : public MediaTrackHelper {
     FFmpegSource(FFmpegExtractor *extractor, size_t index);
 
-    virtual status_t start(MetaDataBase *params);
-    virtual status_t stop();
-    virtual status_t getFormat(MetaDataBase &meta);
+    virtual media_status_t start();
+    virtual media_status_t stop();
+    virtual media_status_t getFormat(AMediaFormat *meta);
 
-    virtual status_t read(
-            MediaBufferBase **buffer, const ReadOptions *options);
+    virtual media_status_t read(
+            MediaBufferHelper **buffer, const ReadOptions *options);
 
 protected:
     virtual ~FFmpegSource();
@@ -113,7 +111,7 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-FFmpegExtractor::FFmpegExtractor(DataSourceBase *source, const sp<AMessage> &meta)
+FFmpegExtractor::FFmpegExtractor(DataSourceHelper *source, const sp<AMessage> &meta)
     : mDataSource(source),
       mInitCheck(NO_INIT),
       mFormatCtx(NULL),
@@ -121,6 +119,7 @@ FFmpegExtractor::FFmpegExtractor(DataSourceBase *source, const sp<AMessage> &met
       mParsedMetadata(false) {
     ALOGV("FFmpegExtractor::FFmpegExtractor");
 
+    mMeta = AMediaFormat_new();
     fetchStuffsFromSniffedMeta(meta);
 
     packet_queue_init(&mVideoQ);
@@ -155,13 +154,18 @@ FFmpegExtractor::~FFmpegExtractor() {
 
     Mutex::Autolock autoLock(mLock);
     deInitStreams();
+
+    for (auto& trackInfo : mTracks) {
+        AMediaFormat_delete(trackInfo.mMeta);
+    }
+    AMediaFormat_delete(mMeta);
 }
 
 size_t FFmpegExtractor::countTracks() {
     return mInitCheck == OK ? mTracks.size() : 0;
 }
 
-MediaTrack* FFmpegExtractor::getTrack(size_t index) {
+MediaTrackHelper* FFmpegExtractor::getTrack(size_t index) {
     ALOGV("FFmpegExtractor::getTrack[%zu]", index);
 
     if (mInitCheck != OK) {
@@ -175,33 +179,33 @@ MediaTrack* FFmpegExtractor::getTrack(size_t index) {
     return new FFmpegSource(this, index);
 }
 
-status_t FFmpegExtractor::getTrackMetaData(MetaDataBase &meta, size_t index, uint32_t flags __unused) {
+media_status_t FFmpegExtractor::getTrackMetaData(AMediaFormat *meta, size_t index, uint32_t flags __unused) {
     ALOGV("FFmpegExtractor::getTrackMetaData[%zu]", index);
 
     if (mInitCheck != OK) {
-        return UNKNOWN_ERROR;
+        return AMEDIA_ERROR_UNKNOWN;
     }
 
     if (index >= mTracks.size()) {
-        return UNKNOWN_ERROR;
+        return AMEDIA_ERROR_UNKNOWN;
     }
 
     /* Quick and dirty, just get a frame 1/4 in */
     if (mTracks.itemAt(index).mIndex == mVideoStreamIdx &&
             mFormatCtx->duration != AV_NOPTS_VALUE) {
-        mTracks.editItemAt(index).mMeta.setInt64(
-                kKeyThumbnailTime, mFormatCtx->duration / 4);
+        AMediaFormat_setInt64(mTracks.editItemAt(index).mMeta,
+                AMEDIAFORMAT_KEY_THUMBNAIL_TIME, mFormatCtx->duration / 4);
     }
 
-    meta = mTracks.itemAt(index).mMeta;
-    return OK;
+    AMediaFormat_copy(meta, mTracks.itemAt(index).mMeta);
+    return AMEDIA_OK;
 }
 
-status_t FFmpegExtractor::getMetaData(MetaDataBase &meta) {
+media_status_t FFmpegExtractor::getMetaData(AMediaFormat *meta) {
     ALOGV("FFmpegExtractor::getMetaData");
 
     if (mInitCheck != OK) {
-        return UNKNOWN_ERROR;
+        return AMEDIA_ERROR_UNKNOWN;
     }
 
     if (!mParsedMetadata) {
@@ -209,8 +213,8 @@ status_t FFmpegExtractor::getMetaData(MetaDataBase &meta) {
         mParsedMetadata = true;
     }
 
-    meta = mMeta;
-    return OK;
+    AMediaFormat_copy(meta, mMeta);
+    return AMEDIA_OK;
 }
 
 uint32_t FFmpegExtractor::flags() const {
@@ -364,10 +368,10 @@ bool FFmpegExtractor::is_codec_supported(enum AVCodecID codec_id)
     return supported;
 }
 
-status_t FFmpegExtractor::setVideoFormat(AVStream *stream, MetaDataBase &meta)
+media_status_t FFmpegExtractor::setVideoFormat(AVStream *stream, AMediaFormat *meta)
 {
     AVCodecContext *avctx = NULL;
-    status_t ret = UNKNOWN_ERROR;
+    media_status_t ret = AMEDIA_ERROR_UNKNOWN;
 
     avctx = stream->codec;
     CHECK_EQ((int)avctx->codec_type, (int)AVMEDIA_TYPE_VIDEO);
@@ -428,16 +432,16 @@ status_t FFmpegExtractor::setVideoFormat(AVStream *stream, MetaDataBase &meta)
     default:
         ALOGD("unsupported video codec (id: %d, name: %s), but give it a chance",
                 avctx->codec_id, avcodec_get_name(avctx->codec_id));
-        meta.setInt32(kKeyCodecId, avctx->codec_id);
-        meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FFMPEG);
+        AMediaFormat_setInt32(meta, "codec-id", avctx->codec_id);
+        AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_FFMPEG);
         if (avctx->extradata_size > 0) {
-            meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+            AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
         }
         //CHECK(!"Should not be here. Unsupported codec.");
         break;
     }
 
-    if (ret == OK) {
+    if (ret == AMEDIA_OK) {
         // rotation
         double theta = get_rotation(stream);
         int rotationDegrees = 0;
@@ -450,11 +454,11 @@ status_t FFmpegExtractor::setVideoFormat(AVStream *stream, MetaDataBase &meta)
             rotationDegrees = 270;
         }
         if (rotationDegrees != 0) {
-            meta.setInt32(kKeyRotation, rotationDegrees);
+            AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_ROTATION, rotationDegrees);
         }
     }
 
-    if (ret == OK) {
+    if (ret == AMEDIA_OK) {
         float aspect_ratio;
         int width, height;
 
@@ -474,28 +478,28 @@ status_t FFmpegExtractor::setVideoFormat(AVStream *stream, MetaDataBase &meta)
         ALOGI("width: %d, height: %d, bit_rate: % " PRId64 " aspect ratio: %f",
                 avctx->width, avctx->height, avctx->bit_rate, aspect_ratio);
 
-        meta.setInt32(kKeyWidth, avctx->width);
-        meta.setInt32(kKeyHeight, avctx->height);
+        AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_WIDTH, avctx->width);
+        AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_HEIGHT, avctx->height);
         if ((width > 0) && (height > 0) &&
             ((avctx->width != width || avctx->height != height))) {
-            meta.setInt32(kKeySARWidth, width);
-            meta.setInt32(kKeySARHeight, height);
+            AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_SAR_WIDTH, width);
+            AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_SAR_HEIGHT, height);
             ALOGI("SAR width: %d, SAR height: %d", width, height);
         }
         if (avctx->bit_rate > 0) {
-            meta.setInt32(kKeyBitRate, avctx->bit_rate);
+            AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_BIT_RATE, avctx->bit_rate);
         }
-        meta.setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
+        AMediaFormat_setString(meta, "file-format", findMatchingContainer(mFormatCtx->iformat->name));
         setDurationMetaData(stream, meta);
     }
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t FFmpegExtractor::setAudioFormat(AVStream *stream, MetaDataBase &meta)
+media_status_t FFmpegExtractor::setAudioFormat(AVStream *stream, AMediaFormat *meta)
 {
     AVCodecContext *avctx = NULL;
-    status_t ret = UNKNOWN_ERROR;
+    media_status_t ret = AMEDIA_ERROR_UNKNOWN;
 
     avctx = stream->codec;
     CHECK_EQ((int)avctx->codec_type, (int)AVMEDIA_TYPE_AUDIO);
@@ -546,17 +550,17 @@ status_t FFmpegExtractor::setAudioFormat(AVStream *stream, MetaDataBase &meta)
     default:
         ALOGD("unsupported audio codec (id: %d, name: %s), but give it a chance",
                 avctx->codec_id, avcodec_get_name(avctx->codec_id));
-        meta.setInt32(kKeyCodecId, avctx->codec_id);
-        meta.setInt32(kKeyCodedSampleBits, avctx->bits_per_coded_sample);
-        meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FFMPEG);
+        AMediaFormat_setInt32(meta, "codec-id", avctx->codec_id);
+        AMediaFormat_setInt32(meta, "coded-sample-bits", avctx->bits_per_coded_sample);
+        AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_FFMPEG);
         if (avctx->extradata_size > 0) {
-            meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+            AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
         }
         //CHECK(!"Should not be here. Unsupported codec.");
         break;
     }
 
-    if (ret == OK) {
+    if (ret == AMEDIA_OK) {
         ALOGD("bit_rate: %" PRId64 ", sample_rate: %d, channels: %d, "
                 "bits_per_coded_sample: %d, block_align: %d "
                 "bits_per_raw_sample: %d, sample_format: %d",
@@ -564,24 +568,24 @@ status_t FFmpegExtractor::setAudioFormat(AVStream *stream, MetaDataBase &meta)
                 avctx->bits_per_coded_sample, avctx->block_align,
                 avctx->bits_per_raw_sample, avctx->sample_fmt);
 
-        meta.setInt32(kKeyChannelCount, avctx->channels);
-        meta.setInt32(kKeyBitRate, avctx->bit_rate);
+        AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_CHANNEL_COUNT, avctx->channels);
+        AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_BIT_RATE, avctx->bit_rate);
         int32_t bits = avctx->bits_per_raw_sample > 0 ?
                 avctx->bits_per_raw_sample :
                 av_get_bytes_per_sample(avctx->sample_fmt) * 8;
-        meta.setInt32(kKeyBitsPerRawSample, bits);
-        meta.setInt32(kKeySampleRate, avctx->sample_rate);
-        meta.setInt32(kKeyBlockAlign, avctx->block_align);
-        meta.setInt32(kKeySampleFormat, avctx->sample_fmt);
-        //meta.setInt32(kKeyPcmEncoding, sampleFormatToEncoding(avctx->sample_fmt));
-        meta.setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
+        AMediaFormat_setInt32(meta, "bits-per-raw-sample", bits);
+        AMediaFormat_setInt32(meta, "sample-rate", avctx->sample_rate);
+        AMediaFormat_setInt32(meta, "block-align", avctx->block_align);
+        AMediaFormat_setInt32(meta, "sample-format", avctx->sample_fmt);
+        //AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_PCM_ENCODING, sampleFormatToEncoding(avctx->sample_fmt));
+        AMediaFormat_setString(meta, "file-format", findMatchingContainer(mFormatCtx->iformat->name));
         setDurationMetaData(stream, meta);
     }
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-void FFmpegExtractor::setDurationMetaData(AVStream *stream, MetaDataBase &meta)
+void FFmpegExtractor::setDurationMetaData(AVStream *stream, AMediaFormat *meta)
 {
     AVCodecContext *avctx = stream->codec;
 
@@ -594,10 +598,10 @@ void FFmpegExtractor::setDurationMetaData(AVStream *stream, MetaDataBase &meta)
         } else {
             ALOGV("%s startTime:N/A", s);
         }
-        meta.setInt64(kKeyDuration, duration);
+        AMediaFormat_setInt64(meta, AMEDIAFORMAT_KEY_DURATION, duration);
     } else {
         // default when no stream duration
-        meta.setInt64(kKeyDuration, mFormatCtx->duration);
+        AMediaFormat_setInt64(meta, AMEDIAFORMAT_KEY_DURATION, mFormatCtx->duration);
     }
 }
 
@@ -638,7 +642,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), avctx->codec_tag);
     ALOGV("Tag %s/0x%08x with codec(%s)\n", tagbuf, avctx->codec_tag, avcodec_get_name(avctx->codec_id));
 
-    MetaDataBase meta;
+    AMediaFormat *meta = AMediaFormat_new();
 
     switch (avctx->codec_type) {
     case AVMEDIA_TYPE_VIDEO:
@@ -666,7 +670,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
             ALOGV("video stream no extradata, but we can ignore it.");
         }
 #endif
-        if (setVideoFormat(mVideoStream, meta) != OK) {
+        if (setVideoFormat(mVideoStream, meta) != AMEDIA_OK) {
             ALOGE("setVideoFormat failed");
             return -1;
         }
@@ -707,7 +711,7 @@ int FFmpegExtractor::stream_component_open(int stream_index)
             ALOGV("audio stream no extradata, but we can ignore it.");
         }
 #endif
-        if (setAudioFormat(mAudioStream, meta) != OK) {
+        if (setAudioFormat(mAudioStream, meta) != AMEDIA_OK) {
             ALOGE("setAudioFormat failed");
             return -1;
         }
@@ -800,7 +804,7 @@ void FFmpegExtractor::reachedEOS(enum AVMediaType media_type)
 
 /* seek in the stream */
 int FFmpegExtractor::stream_seek(int64_t pos, enum AVMediaType media_type,
-        MediaSource::ReadOptions::SeekMode mode)
+        MediaTrackHelper::ReadOptions::SeekMode mode)
 {
     Mutex::Autolock _l(mLock);
 
@@ -826,19 +830,19 @@ int FFmpegExtractor::stream_seek(int64_t pos, enum AVMediaType media_type,
     //}
 
     switch (mode) {
-        case MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC:
+        case MediaTrackHelper::ReadOptions::SEEK_PREVIOUS_SYNC:
             mSeekMin = 0;
             mSeekMax = mSeekPos;
             break;
-        case MediaSource::ReadOptions::SEEK_NEXT_SYNC:
+        case MediaTrackHelper::ReadOptions::SEEK_NEXT_SYNC:
             mSeekMin = mSeekPos;
             mSeekMax = INT64_MAX;
             break;
-        case MediaSource::ReadOptions::SEEK_CLOSEST_SYNC:
+        case MediaTrackHelper::ReadOptions::SEEK_CLOSEST_SYNC:
             mSeekMin = 0;
             mSeekMax = INT64_MAX;
             break;
-        case MediaSource::ReadOptions::SEEK_CLOSEST:
+        case MediaTrackHelper::ReadOptions::SEEK_CLOSEST:
             mSeekMin = 0;
             mSeekMax = mSeekPos;
             break;
@@ -873,7 +877,7 @@ void FFmpegExtractor::fetchStuffsFromSniffedMeta(const sp<AMessage> &meta)
     //mime
     CHECK(meta->findString("extended-extractor-mime", &mime));
     CHECK(mime.c_str() != NULL);
-    mMeta.setCString(kKeyMIMEType, mime.c_str());
+    AMediaFormat_setString(mMeta, AMEDIAFORMAT_KEY_MIME, mime.c_str());
 }
 
 void FFmpegExtractor::setFFmpegDefaultOpts()
@@ -1326,7 +1330,7 @@ FFmpegSource::FFmpegSource(
       mQueue(mExtractor->mTracks.itemAt(index).mQueue),
       mLastPTS(AV_NOPTS_VALUE),
       mTargetTime(AV_NOPTS_VALUE) {
-    const MetaDataBase& meta = mExtractor->mTracks.itemAt(index).mMeta;
+    AMediaFormat *meta = mExtractor->mTracks.itemAt(index).mMeta;
 
     {
         AVCodecContext *avctx = mStream->codec;
@@ -1337,10 +1341,9 @@ FFmpegSource::FFmpegSource(
                 && avctx->extradata[0] == 1) {
             mIsAVC = true;
 
-            uint32_t type;
-            const void *data;
+            void *data;
             size_t size;
-            CHECK(meta.findData(kKeyAVCC, &type, &data, &size));
+            CHECK(AMediaFormat_getBuffer(meta, AMEDIAFORMAT_KEY_CSD_AVC, &data, &size));
 
             const uint8_t *ptr = (const uint8_t *)data;
 
@@ -1363,10 +1366,9 @@ FFmpegSource::FFmpegSource(
              * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
             mIsHEVC = true;
 
-            uint32_t type;
-            const void *data;
+            void *data;
             size_t size;
-            CHECK(meta.findData(kKeyHVCC, &type, &data, &size));
+            CHECK(AMediaFormat_getBuffer(meta, AMEDIAFORMAT_KEY_CSD_HEVC, &data, &size));
 
             const uint8_t *ptr = (const uint8_t *)data;
 
@@ -1393,25 +1395,26 @@ FFmpegSource::~FFmpegSource() {
     mExtractor = NULL;
 }
 
-status_t FFmpegSource::start(MetaDataBase * /* params */) {
+media_status_t FFmpegSource::start() {
     ALOGV("FFmpegSource::start %s",
             av_get_media_type_string(mMediaType));
-    return OK;
+    mBufferGroup->init(1, 1024, 64);
+    return AMEDIA_OK;
 }
 
-status_t FFmpegSource::stop() {
+media_status_t FFmpegSource::stop() {
     ALOGV("FFmpegSource::stop %s",
             av_get_media_type_string(mMediaType));
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t FFmpegSource::getFormat(MetaDataBase &meta) {
-    meta = mExtractor->mTracks.itemAt(mTrackIndex).mMeta;
-    return OK;
+media_status_t FFmpegSource::getFormat(AMediaFormat *meta) {
+    AMediaFormat_copy(meta, mExtractor->mTracks.itemAt(mTrackIndex).mMeta);
+    return AMEDIA_OK;
 }
 
-status_t FFmpegSource::read(
-        MediaBufferBase **buffer, const ReadOptions *options) {
+media_status_t FFmpegSource::read(
+        MediaBufferHelper **buffer, const ReadOptions *options) {
     *buffer = NULL;
 
     AVPacket pkt;
@@ -1422,7 +1425,7 @@ status_t FFmpegSource::read(
     int64_t seekTimeUs = AV_NOPTS_VALUE;
     int64_t timeUs = AV_NOPTS_VALUE;
     int key = 0;
-    status_t status = OK;
+    media_status_t status = AMEDIA_OK;
     int max_negative_time_frame = 100;
 
     int64_t startTimeUs = mStream->start_time == AV_NOPTS_VALUE ? 0 :
@@ -1443,7 +1446,7 @@ retry:
     if (packet_queue_get(mQueue, &pkt, 1) < 0) {
         ALOGD("read %s abort reqeust", av_get_media_type_string(mMediaType));
         mExtractor->reachedEOS(mMediaType);
-        return ERROR_END_OF_STREAM;
+        return AMEDIA_ERROR_END_OF_STREAM;
     }
 
     if (seeking) {
@@ -1467,7 +1470,7 @@ retry:
         ALOGD("read %s eos pkt", av_get_media_type_string(mMediaType));
         av_packet_unref(&pkt);
         mExtractor->reachedEOS(mMediaType);
-        return ERROR_END_OF_STREAM;
+        return AMEDIA_ERROR_END_OF_STREAM;
     }
 
     key = pkt.flags & AV_PKT_FLAG_KEY ? 1 : 0;
@@ -1489,8 +1492,9 @@ retry:
         mFirstKeyPktTimestamp = pktTS;
     }
 
-    MediaBuffer *mediaBuffer = new MediaBuffer(pkt.size + AV_INPUT_BUFFER_PADDING_SIZE);
-    mediaBuffer->meta_data().clear();
+    MediaBufferHelper *mediaBuffer;
+    mBufferGroup->acquire_buffer(&mediaBuffer, false, pkt.size + AV_INPUT_BUFFER_PADDING_SIZE);
+    AMediaFormat_clear(mediaBuffer->meta_data());
     mediaBuffer->set_range(0, pkt.size);
 
     //copy data
@@ -1501,18 +1505,18 @@ retry:
             mediaBuffer->release();
             mediaBuffer = NULL;
             av_packet_unref(&pkt);
-            return ERROR_MALFORMED;
+            return AMEDIA_ERROR_MALFORMED;
         }
 
         uint8_t *dst = (uint8_t *)mediaBuffer->data();
         /* Convert H.264 NAL format to annex b */
         status = convertNal2AnnexB(dst, pkt.size, pkt.data, pkt.size, mNALLengthSize);
-        if (status != OK) {
+        if (status != AMEDIA_OK) {
             ALOGE("convertNal2AnnexB failed");
             mediaBuffer->release();
             mediaBuffer = NULL;
             av_packet_unref(&pkt);
-            return ERROR_MALFORMED;
+            return AMEDIA_ERROR_MALFORMED;
         }
     } else {
         memcpy(mediaBuffer->data(), pkt.data, pkt.size);
@@ -1539,7 +1543,7 @@ retry:
             goto retry;
         } else {
             ALOGE("too many negative timestamp packets, abort decoding");
-            return ERROR_MALFORMED;
+            return AMEDIA_ERROR_MALFORMED;
         }
     }
 
@@ -1561,14 +1565,14 @@ retry:
             av_get_media_type_string(mMediaType), pkt.size, key);
 #endif
 
-    mediaBuffer->meta_data().setInt64(kKeyTime, timeUs);
-    mediaBuffer->meta_data().setInt32(kKeyIsSyncFrame, key);
+    AMediaFormat_setInt64(mediaBuffer->meta_data(), AMEDIAFORMAT_KEY_TIME_US, timeUs);
+    AMediaFormat_setInt32(mediaBuffer->meta_data(), AMEDIAFORMAT_KEY_IS_SYNC_FRAME, key);
 
     // deal with seek-to-exact-frame, we might be off a bit and Stagefright will assert on us
     if (seekTimeUs != AV_NOPTS_VALUE && timeUs < seekTimeUs &&
             mode == MediaSource::ReadOptions::SEEK_CLOSEST) {
         mTargetTime = seekTimeUs;
-        mediaBuffer->meta_data().setInt64(kKeyTargetTime, seekTimeUs);
+        AMediaFormat_setInt64(mediaBuffer->meta_data(), AMEDIAFORMAT_KEY_TARGET_TIME, seekTimeUs);
     }
 
     if (mTargetTime != AV_NOPTS_VALUE) {
@@ -1576,7 +1580,7 @@ retry:
             mTargetTime = AV_NOPTS_VALUE;
         } else if (nextPTS != AV_NOPTS_VALUE && nextPTS > mTargetTime) {
             ALOGV("adjust target frame time to %" PRId64, timeUs);
-            mediaBuffer->meta_data().setInt64(kKeyTime, mTargetTime);
+            AMediaFormat_setInt64(mediaBuffer->meta_data(), AMEDIAFORMAT_KEY_TIME_US, mTargetTime);
             mTargetTime = AV_NOPTS_VALUE;
         }
     }
@@ -1585,7 +1589,7 @@ retry:
 
     av_packet_unref(&pkt);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -2091,7 +2095,7 @@ fail:
     return container;
 }
 
-static const char *BetterSniffFFMPEG(DataSourceBase *source,
+static const char *BetterSniffFFMPEG(CDataSource *source,
         float *confidence, AMessage *meta)
 {
     const char *ret = NULL;
@@ -2103,7 +2107,7 @@ static const char *BetterSniffFFMPEG(DataSourceBase *source,
     snprintf(url, sizeof(url), "android-source:%p", source);
 
     ret = SniffFFMPEGCommon(url, confidence,
-            (source->flags() & DataSource::kIsCachingDataSource));
+            (source->flags(source->handle) & DataSourceBase::kIsCachingDataSource));
     if (ret) {
         meta->setString("extended-extractor-url", url);
     }
@@ -2111,18 +2115,18 @@ static const char *BetterSniffFFMPEG(DataSourceBase *source,
     return ret;
 }
 
-static const char *LegacySniffFFMPEG(DataSourceBase *source,
+static const char *LegacySniffFFMPEG(CDataSource *source,
          float *confidence, AMessage *meta)
 {
     const char *ret = NULL;
     char uri[PATH_MAX] = {0};
     char url[PATH_MAX] = {0};
 
-    if (!source->getUri(uri, sizeof(uri))) {
+    if (!source->getUri(source->handle, uri, sizeof(uri))) {
         return NULL;
     }
 
-    if (source->flags() & DataSource::kIsCachingDataSource)
+    if (source->flags(source->handle) & DataSourceBase::kIsCachingDataSource)
        return NULL;
 
     ALOGV("source url:%s", uri);
@@ -2144,10 +2148,10 @@ static void FreeMeta(void *meta) {
     }
 }
 
-static MediaExtractor::CreatorFunc
+static CreatorFunc
 SniffFFMPEG(
-        DataSourceBase *source, float *confidence, void **meta,
-        MediaExtractor::FreeMetaFunc *freeMeta) {
+        CDataSource *source, float *confidence, void **meta,
+        FreeMetaFunc *freeMeta) {
 
     float newConfidence = 0.08f;
 
@@ -2209,8 +2213,8 @@ SniffFFMPEG(
     return CreateFFMPEGExtractor;
 }
 
-static MediaExtractor *CreateFFMPEGExtractor(DataSourceBase *source, void *meta) {
-    MediaExtractor *ret = NULL;
+static CMediaExtractor *CreateFFMPEGExtractor(CDataSource *source, void *meta) {
+    CMediaExtractor *ret = NULL;
     sp<AMessage> msg = static_cast<AMessage *>(meta);
     AString mime;
     if (msg.get() && msg->findString("extended-extractor-mime", &mime) && (
@@ -2250,23 +2254,31 @@ static MediaExtractor *CreateFFMPEGExtractor(DataSourceBase *source, void *meta)
             !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_HEVC)      ||
             !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WMA)       ||
             !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_FFMPEG))) {
-        ret = new FFmpegExtractor(source, msg);
+        ret = wrap(new FFmpegExtractor(new DataSourceHelper(source), msg));
     }
 
     ALOGD("%ssupported mime: %s", (ret ? "" : "un"), mime.c_str());
     return ret;
 }
 
+static const char* extensions[] = {
+    "adts",
+    "dm", "m2ts", "mp3d", "wmv", "asf", "flv", ".ra",
+    "rm", "rmvb", "ac3", "ape", "dts", "mp1", "mp2",
+    "f4v", "hlv", "nrg", "m2v", "swf", "vc1", "vob",
+    "divx", "qcp", "ec3"
+};
+
 extern "C" {
 
 __attribute__ ((visibility ("default")))
-MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
+ExtractorDef GETEXTRACTORDEF() {
     return {
-        MediaExtractor::EXTRACTORDEF_VERSION,
+        EXTRACTORDEF_VERSION,
         UUID("280e1e71-d08b-4d8c-ba03-d775497fc4bc"),
         1, // version
         "FFMPEG Extractor",
-        SniffFFMPEG
+        { .v3 = { SniffFFMPEG, extensions } }
     };
 }
 

diff --git a/extractor/FFmpegExtractor.h b/extractor/FFmpegExtractor.h
index 4a8e1b8..a106b36 100644 (file)
--- a/extractor/FFmpegExtractor.h
+++ b/extractor/FFmpegExtractor.h
@@ -18,8 +18,9 @@
 
 #define SUPER_EXTRACTOR_H_
 
-#include <media/MediaExtractor.h>
-#include <media/MediaSource.h>
+#include <media/MediaExtractorPluginApi.h>
+#include <media/MediaExtractorPluginHelper.h>
+#include <media/NdkMediaFormat.h>
 #include <media/stagefright/foundation/ABase.h>
 #include <utils/threads.h>
 #include <utils/KeyedVector.h>
@@ -33,16 +34,17 @@ struct AMessage;
 class String8;
 struct FFmpegSource;
 
-struct FFmpegExtractor : public MediaExtractor {
-    FFmpegExtractor(DataSourceBase *source, const sp<AMessage> &meta);
+struct FFmpegExtractor : public MediaExtractorPluginHelper {
+    FFmpegExtractor(DataSourceHelper *source, const sp<AMessage> &meta);
 
     virtual size_t countTracks();
-    virtual MediaTrack* getTrack(size_t index);
-    virtual status_t getTrackMetaData(MetaDataBase &meta, size_t index, uint32_t flags);
+    virtual MediaTrackHelper* getTrack(size_t index);
+    virtual media_status_t getTrackMetaData(AMediaFormat *meta, size_t index, uint32_t flags);
 
-    virtual status_t getMetaData(MetaDataBase &meta);
+    virtual media_status_t getMetaData(AMediaFormat *meta);
 
     virtual uint32_t flags() const;
+    virtual const char* name() { return "FFmpegExtractor"; }
 
 protected:
     virtual ~FFmpegExtractor();
@@ -52,7 +54,7 @@ private:
 
     struct TrackInfo {
         int mIndex; //stream index
-        MetaDataBase mMeta;
+        AMediaFormat *mMeta;
         AVStream *mStream;
         PacketQueue *mQueue;
     };
@@ -63,8 +65,8 @@ private:
     mutable Mutex mExtractorMutex;
     Condition mCondition;
 
-    DataSourceBase *mDataSource;
-    MetaDataBase mMeta;
+    DataSourceHelper *mDataSource;
+    AMediaFormat *mMeta;
     status_t mInitCheck;
 
     char mFilename[PATH_MAX];
@@ -84,7 +86,7 @@ private:
     int mPaused;
     int mLastPaused;
     int mSeekIdx;
-    MediaSource::ReadOptions::SeekMode mSeekMode;
+    MediaTrackHelper::ReadOptions::SeekMode mSeekMode;
     int64_t mSeekPos;
     int64_t mSeekMin;
     int64_t mSeekMax;
@@ -112,14 +114,14 @@ private:
     void setFFmpegDefaultOpts();
     void printTime(int64_t time);
     bool is_codec_supported(enum AVCodecID codec_id);
-    status_t setVideoFormat(AVStream *stream, MetaDataBase &meta);
-    status_t setAudioFormat(AVStream *stream, MetaDataBase &meta);
-    void setDurationMetaData(AVStream *stream, MetaDataBase &meta);
+    media_status_t setVideoFormat(AVStream *stream, AMediaFormat *meta);
+    media_status_t setAudioFormat(AVStream *stream, AMediaFormat *meta);
+    void setDurationMetaData(AVStream *stream, AMediaFormat *meta);
     int stream_component_open(int stream_index);
     void stream_component_close(int stream_index);
     void reachedEOS(enum AVMediaType media_type);
     int stream_seek(int64_t pos, enum AVMediaType media_type,
-            MediaSource::ReadOptions::SeekMode mode);
+            MediaTrackHelper::ReadOptions::SeekMode mode);
     int check_extradata(AVCodecContext *avctx);
 
     bool mReaderThreadStarted;
@@ -134,21 +136,6 @@ private:
     DISALLOW_EVIL_CONSTRUCTORS(FFmpegExtractor);
 };
 
-/*
-extern "C" {
-
-static const char *findMatchingContainer(const char *name);
-
-bool SniffFFMPEG(
-        const sp<DataSource> &source, String8 *mimeType, float *confidence,
-        sp<AMessage> *);
-
-MediaExtractor* CreateFFMPEGExtractor(const sp<DataSource> &source,
-        const char *mime, const sp<AMessage> &meta);
-
-}
-*/
-
 }  // namespace android
 
 #endif  // SUPER_EXTRACTOR_H_

diff --git a/omx/Android.mk b/omx/Android.mk
index 647a299..08cf15e 100644 (file)
--- a/omx/Android.mk
+++ b/omx/Android.mk
@@ -19,7 +19,7 @@ LOCAL_SHARED_LIBRARIES += \
        liblog            \
        libnativewindow   \
        libswscale        \
-       libstagefright_omx
+       libstagefright_softomx
 
 LOCAL_MODULE:= libffmpeg_omx
 

diff --git a/utils/Android.mk b/utils/Android.mk
index 58323b9..f370b93 100644 (file)
--- a/utils/Android.mk
+++ b/utils/Android.mk
@@ -10,8 +10,7 @@ LOCAL_SRC_FILES := \
 
 LOCAL_SHARED_LIBRARIES += \
        liblog            \
-       libmediaextractor \
-       libstagefright
+       libmediandk
 
 LOCAL_STATIC_LIBRARIES += libstagefright_metadatautils
 

diff --git a/utils/codec_utils.cpp b/utils/codec_utils.cpp
index 66ff92a..c96b83d 100644 (file)
--- a/utils/codec_utils.cpp
+++ b/utils/codec_utils.cpp
@@ -26,12 +26,11 @@ extern "C" {
 }
 
 #include <utils/Errors.h>
+#include <media/NdkMediaFormat.h>
 #include <media/stagefright/foundation/ABitReader.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/avc_utils.h>
 #include <media/stagefright/MediaDefs.h>
-#include <media/stagefright/MediaErrors.h>
-#include <media/stagefright/MetaData.h>
 #include <media/stagefright/MetaDataUtils.h>
 
 #include "codec_utils.h"
@@ -84,7 +83,7 @@ static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) {
 //http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
 
 // H.264 bitstream without start codes.
-status_t setAVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setAVCFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("AVC");
 
@@ -100,26 +99,26 @@ status_t setAVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
          avctx->height = height;
      }
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
-    meta.setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_AVC);
+    AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CSD_AVC, avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
 // H.264 bitstream with start codes.
-status_t setH264Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setH264Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("H264");
 
     CHECK_NE((int)avctx->extradata[0], 1); //configurationVersion
 
     if (!MakeAVCCodecSpecificData(meta, avctx->extradata, avctx->extradata_size))
-      return UNKNOWN_ERROR;
+      return AMEDIA_ERROR_UNKNOWN;
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setMPEG4Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setMPEG4Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("MPEG4");
 
@@ -127,28 +126,28 @@ status_t setMPEG4Format(AVCodecContext *avctx, MetaDataBase &meta)
     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 
-    meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
+    AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_ESDS, esds->data(), esds->size());
 
     int divxVersion = getDivXVersion(avctx);
     if (divxVersion >= 0) {
-        meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
-        meta.setInt32(kKeyDivXVersion, divxVersion);
+        AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_DIVX);
+        AMediaFormat_setInt32(meta, "divx-version", divxVersion);
     } else {
-        meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
+        AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_MPEG4);
     }
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setH263Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
+media_status_t setH263Format(AVCodecContext *avctx __unused, AMediaFormat *meta)
 {
     ALOGV("H263");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_H263);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("MPEG%uVIDEO", avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 2 : 1);
 
@@ -156,146 +155,146 @@ status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, MetaDataBase &meta)
     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 
-    meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
+    AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_ESDS, esds->data(), esds->size());
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_MPEG2);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setVC1Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setVC1Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("VC1");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_VC1);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setWMV1Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
+media_status_t setWMV1Format(AVCodecContext *avctx __unused, AMediaFormat *meta)
 {
     ALOGV("WMV1");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
-    meta.setInt32(kKeyWMVVersion, kTypeWMVVer_7);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_WMV);
+    AMediaFormat_setInt32(meta, "wmv-version", kTypeWMVVer_7);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setWMV2Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setWMV2Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("WMV2");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyWMVVersion, kTypeWMVVer_8);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_WMV);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "wmv-version", kTypeWMVVer_8);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setWMV3Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setWMV3Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("WMV3");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyWMVVersion, kTypeWMVVer_9);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_WMV);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "wmv-version", kTypeWMVVer_9);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setRV20Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setRV20Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("RV20");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVide
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_RV);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "rv-version", kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVide
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setRV30Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setRV30Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("RV30");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVide
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_RV);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "rv-version", kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVide
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setRV40Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setRV40Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("RV40");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVide
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_RV);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "rv-version", kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVide
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setFLV1Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setFLV1Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("FLV1(Sorenson H263)");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_FLV1);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setHEVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setHEVCFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("HEVC");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
-    meta.setData(kKeyHVCC, kTypeHVCC, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_HEVC);
+    AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CSD_HEVC, avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setVP8Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
+media_status_t setVP8Format(AVCodecContext *avctx __unused, AMediaFormat *meta)
 {
     ALOGV("VP8");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_VP8);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setVP9Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
+media_status_t setVP9Format(AVCodecContext *avctx __unused, AMediaFormat *meta)
 {
     ALOGV("VP9");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_VIDEO_VP9);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
 //audio
 
-status_t setMP2Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
+media_status_t setMP2Format(AVCodecContext *avctx __unused, AMediaFormat *meta)
 {
     ALOGV("MP2");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setMP3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
+media_status_t setMP3Format(AVCodecContext *avctx __unused, AMediaFormat *meta)
 {
     ALOGV("MP3");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_MPEG);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setVORBISFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setVORBISFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("VORBIS");
 
@@ -305,132 +304,132 @@ status_t setVORBISFormat(AVCodecContext *avctx, MetaDataBase &meta)
                 avctx->extradata_size, 30,
                 header_start, header_len) < 0) {
         ALOGE("vorbis extradata corrupt.");
-        return UNKNOWN_ERROR;
+        return AMEDIA_ERROR_UNKNOWN;
     }
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_VORBIS);
     //identification header
-    meta.setData(kKeyVorbisInfo,  0, header_start[0], header_len[0]);
+    AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CSD_0, header_start[0], header_len[0]);
     //setup header
-    meta.setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
+    AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_CSD_1, header_start[2], header_len[2]);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setAC3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
+media_status_t setAC3Format(AVCodecContext *avctx __unused, AMediaFormat *meta)
 {
     ALOGV("AC3");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_AC3);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setAACFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setAACFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("AAC");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyAACAOT, avctx->profile + 1);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_AAC);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, AMEDIAFORMAT_KEY_AAC_PROFILE, avctx->profile + 1);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setWMAV1Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setWMAV1Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("WMAV1");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_WMA);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "wma-version", kTypeWMA); //FIXME version?
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setWMAV2Format(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setWMAV2Format(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("WMAV2");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyWMAVersion, kTypeWMA);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_WMA);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "wma-version", kTypeWMA); //FIXME version?
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setWMAProFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setWMAProFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("WMAPro");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyWMAVersion, kTypeWMAPro);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_WMA);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "wma-version", kTypeWMAPro);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setWMALossLessFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setWMALossLessFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("WMALOSSLESS");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
-    meta.setInt32(kKeyWMAVersion, kTypeWMALossLess);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_WMA);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setInt32(meta, "wma-version", kTypeWMALossLess);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setRAFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setRAFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("COOK");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_RA);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setALACFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setALACFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("ALAC");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_ALAC);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_ALAC);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setAPEFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setAPEFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("APE");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_APE);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setDTSFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setDTSFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("DTS");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_DTS);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
-status_t setFLACFormat(AVCodecContext *avctx, MetaDataBase &meta)
+media_status_t setFLACFormat(AVCodecContext *avctx, AMediaFormat *meta)
 {
     ALOGV("FLAC");
 
-    meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
-    meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+    AMediaFormat_setString(meta, AMEDIAFORMAT_KEY_MIME, MEDIA_MIMETYPE_AUDIO_FLAC);
+    AMediaFormat_setBuffer(meta, "raw-codec-specific-data", avctx->extradata, avctx->extradata_size);
 
     if (avctx->extradata_size < 10) {
         ALOGE("Invalid extradata in FLAC file! (size=%d)", avctx->extradata_size);
-        return UNKNOWN_ERROR;
+        return AMEDIA_ERROR_UNKNOWN;
     }
 
     ABitReader br(avctx->extradata, avctx->extradata_size);
@@ -439,21 +438,21 @@ status_t setFLACFormat(AVCodecContext *avctx, MetaDataBase &meta)
     int32_t minFrameSize = br.getBits(24);
     int32_t maxFrameSize = br.getBits(24);
 
-    meta.setInt32('mibs', minBlockSize);
-    meta.setInt32('mabs', maxBlockSize);
-    meta.setInt32('mifs', minFrameSize);
-    meta.setInt32('mafs', maxFrameSize);
+    AMediaFormat_setInt32(meta, "min-block-size", minBlockSize);
+    AMediaFormat_setInt32(meta, "max-block-size", maxBlockSize);
+    AMediaFormat_setInt32(meta, "min-frame-size", minFrameSize);
+    AMediaFormat_setInt32(meta, "max-frame-size", maxFrameSize);
 
-    return OK;
+    return AMEDIA_OK;
 }
 
 //Convert H.264 NAL format to annex b
-status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
+media_status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
         uint8_t *src, size_t src_size, size_t nal_len_size)
 {
     size_t i = 0;
     size_t nal_len = 0;
-    status_t status = OK;
+    media_status_t status = AMEDIA_OK;
 
     CHECK_EQ(dst_size, src_size);
     CHECK(nal_len_size == 3 || nal_len_size == 4);
@@ -466,7 +465,7 @@ status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
         }
         dst[nal_len_size - 1] = 1;
         if (nal_len > INT_MAX || nal_len > src_size) {
-            status = ERROR_MALFORMED;
+            status = AMEDIA_ERROR_MALFORMED;
             break;
         }
         dst += nal_len_size;
@@ -502,35 +501,35 @@ int getDivXVersion(AVCodecContext *avctx)
     return -1;
 }
 
-status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta) {
+media_status_t parseMetadataTags(AVFormatContext *ctx, AMediaFormat *meta) {
     if (ctx == NULL) {
-        return NO_INIT;
+        return AMEDIA_ERROR_INVALID_OPERATION;
     }
 
     AVDictionary *dict = ctx->metadata;
     if (dict == NULL) {
-        return NO_INIT;
+        return AMEDIA_ERROR_INVALID_OPERATION;
     }
 
     struct MetadataMapping {
         const char *from;
-        int to;
+        const char *to;
     };
 
     // avformat -> android mapping
     static const MetadataMapping kMap[] = {
-        { "track", kKeyCDTrackNumber },
-        { "disc", kKeyDiscNumber },
-        { "album", kKeyAlbum },
-        { "artist", kKeyArtist },
-        { "album_artist", kKeyAlbumArtist },
-        { "composer", kKeyComposer },
-        { "date", kKeyDate },
-        { "genre", kKeyGenre },
-        { "title", kKeyTitle },
-        { "year", kKeyYear },
-        { "compilation", kKeyCompilation },
-        { "location", kKeyLocation },
+        { "track", AMEDIAFORMAT_KEY_CDTRACKNUMBER },
+        { "disc", AMEDIAFORMAT_KEY_DISCNUMBER },
+        { "album", AMEDIAFORMAT_KEY_ALBUM },
+        { "artist", AMEDIAFORMAT_KEY_ARTIST },
+        { "album_artist", AMEDIAFORMAT_KEY_ALBUMARTIST },
+        { "composer", AMEDIAFORMAT_KEY_COMPOSER },
+        { "date", AMEDIAFORMAT_KEY_DATE },
+        { "genre", AMEDIAFORMAT_KEY_GENRE },
+        { "title", AMEDIAFORMAT_KEY_TITLE },
+        { "year", AMEDIAFORMAT_KEY_YEAR },
+        { "compilation", AMEDIAFORMAT_KEY_COMPILATION },
+        { "location", AMEDIAFORMAT_KEY_LOCATION },
     };
 
     static const size_t kNumEntries = sizeof(kMap) / sizeof(kMap[0]);
@@ -539,7 +538,7 @@ status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta) {
         AVDictionaryEntry *entry = av_dict_get(dict, kMap[i].from, NULL, 0);
         if (entry != NULL) {
             ALOGV("found key %s with value %s", entry->key, entry->value);
-            meta.setCString(kMap[i].to, entry->value);
+            AMediaFormat_setString(meta, kMap[i].to, entry->value);
         }
     }
 
@@ -559,14 +558,14 @@ status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta) {
                     }
                     if (mime != NULL) {
                         ALOGV("found albumart in stream %zu with type %s len %d", i, mime, pkt.size);
-                        meta.setData(kKeyAlbumArt, MetaData::TYPE_NONE, pkt.data, pkt.size);
-                        meta.setCString(kKeyAlbumArtMIME, mime);
+                        AMediaFormat_setBuffer(meta, AMEDIAFORMAT_KEY_ALBUMART, pkt.data, pkt.size);
                     }
                 }
             }
         }
     }
-    return OK;
+
+    return AMEDIA_OK;
 }
 
 AudioEncoding sampleFormatToEncoding(AVSampleFormat fmt) {

diff --git a/utils/codec_utils.h b/utils/codec_utils.h
index d900e8c..719d691 100644 (file)
--- a/utils/codec_utils.h
+++ b/utils/codec_utils.h
@@ -26,48 +26,50 @@
 
 #include "ffmpeg_utils.h"
 
+struct AMediaFormat;
+
 namespace android {
 
 //video
-status_t setAVCFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setH264Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setMPEG4Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setH263Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setVC1Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setWMV1Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setWMV2Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setWMV3Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setRV20Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setRV30Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setRV40Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setFLV1Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setHEVCFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setVP8Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setVP9Format(AVCodecContext *avctx, MetaDataBase &meta);
+media_status_t setAVCFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setH264Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setMPEG4Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setH263Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setVC1Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setWMV1Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setWMV2Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setWMV3Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setRV20Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setRV30Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setRV40Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setFLV1Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setHEVCFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setVP8Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setVP9Format(AVCodecContext *avctx, AMediaFormat *meta);
 //audio
-status_t setMP2Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setMP3Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setVORBISFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setAC3Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setAACFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setWMAV1Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setWMAV2Format(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setWMAProFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setWMALossLessFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setRAFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setAPEFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setDTSFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setFLACFormat(AVCodecContext *avctx, MetaDataBase &meta);
-status_t setALACFormat(AVCodecContext *avctx, MetaDataBase &meta);
+media_status_t setMP2Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setMP3Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setVORBISFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setAC3Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setAACFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setWMAV1Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setWMAV2Format(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setWMAProFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setWMALossLessFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setRAFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setAPEFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setDTSFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setFLACFormat(AVCodecContext *avctx, AMediaFormat *meta);
+media_status_t setALACFormat(AVCodecContext *avctx, AMediaFormat *meta);
 
 //Convert H.264 NAL format to annex b
-status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
+media_status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
         uint8_t *src, size_t src_size, size_t nal_len_size);
 
 int getDivXVersion(AVCodecContext *avctx);
 
-status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta);
+media_status_t parseMetadataTags(AVFormatContext *ctx, AMediaFormat *meta);
 
 AudioEncoding sampleFormatToEncoding(AVSampleFormat fmt);
 AVSampleFormat encodingToSampleFormat(AudioEncoding encoding);

diff --git a/utils/ffmpeg_source.cpp b/utils/ffmpeg_source.cpp
index 0f5afd6..ccd636a 100644 (file)
--- a/utils/ffmpeg_source.cpp
+++ b/utils/ffmpeg_source.cpp
@@ -20,7 +20,7 @@
 #include <stdlib.h>
 #include "ffmpeg_source.h"
 
-#include <media/DataSourceBase.h>
+#include <media/MediaExtractorPluginApi.h>
 
 extern "C" {
 
@@ -34,24 +34,19 @@ namespace android {
 class FFSource
 {
 public:
-    void set(DataSourceBase *s) { mSource = s; }
+    void set(CDataSource *s) { mSource = s; }
     int init_check();
     int read(unsigned char *buf, size_t size);
     int64_t seek(int64_t pos);
     off64_t getSize();
 
 protected:
-    DataSourceBase *mSource;
+    CDataSource *mSource;
     int64_t mOffset;
 };
 
 int FFSource::init_check()
 {
-    if (mSource->initCheck() != OK) {
-        ALOGE("FFSource initCheck failed");
-        return -1;
-    }
-
     return 0;
 }
 
@@ -59,7 +54,7 @@ int FFSource::read(unsigned char *buf, size_t size)
 {
     ssize_t n = 0;
 
-    n = mSource->readAt(mOffset, buf, size);
+    n = mSource->readAt(mSource->handle, mOffset, buf, size);
     if (n == UNKNOWN_ERROR) {
         ALOGE("FFSource readAt failed");
         return AVERROR(errno);
@@ -81,7 +76,7 @@ off64_t FFSource::getSize()
 {
     off64_t sz = -1;
 
-    if (mSource->getSize(&sz) != OK) {
+    if (mSource->getSize(mSource->handle, &sz) != OK) {
          ALOGE("FFSource getSize failed");
          return AVERROR(errno);
     }
@@ -93,9 +88,9 @@ off64_t FFSource::getSize()
 
 static int android_open(URLContext *h, const char *url, int flags __unused)
 {
-    // the url in form of "android-source:<DataSourceBase Ptr>",
+    // the url in form of "android-source:<CDataSource Ptr>",
     // the DataSourceBase Pointer passed by the ffmpeg extractor
-    DataSourceBase *source = NULL;
+    CDataSource *source = NULL;
     char url_check[PATH_MAX] = {0};
 
     ALOGV("android source begin open");
@@ -118,7 +113,7 @@ static int android_open(URLContext *h, const char *url, int flags __unused)
     if (strcmp(url_check, url) != 0) {
 
         char uri[PATH_MAX] = {0};
-        if (!source->getUri(uri, sizeof(uri))) {
+        if (!source->getUri(source->handle, uri, sizeof(uri))) {
             ALOGE("ffmpeg open data source error! (source uri)");
             return -1;
         }