#include <utils/misc.h>
#include <utils/String8.h>
#include <cutils/properties.h>
+#include <media/DataSource.h>
+#include <media/MediaSource.h>
#include <media/stagefright/foundation/ABitReader.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/foundation/avc_utils.h>
#include <media/stagefright/foundation/hexdump.h>
-#include <media/stagefright/DataSource.h>
#include <media/stagefright/MediaBuffer.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaErrors.h>
-#include <media/stagefright/MediaSource.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/Utils.h>
-#include "include/avc_utils.h"
#include "utils/codec_utils.h"
#include "utils/ffmpeg_cmdutils.h"
namespace android {
-struct FFmpegSource : public MediaSource {
- FFmpegSource(const sp<FFmpegExtractor> &extractor, size_t index);
+static const char *findMatchingContainer(const char *name);
+static MediaExtractor *CreateFFMPEGExtractor(DataSourceBase *source, void *meta);
- virtual status_t start(MetaData *params);
+struct FFmpegSource : public MediaTrack {
+ FFmpegSource(FFmpegExtractor *extractor, size_t index);
+
+ virtual status_t start(MetaDataBase *params);
virtual status_t stop();
- virtual sp<MetaData> getFormat();
+ virtual status_t getFormat(MetaDataBase &meta);
virtual status_t read(
- MediaBuffer **buffer, const ReadOptions *options);
+ MediaBufferBase **buffer, const ReadOptions *options);
protected:
virtual ~FFmpegSource();
private:
friend struct FFmpegExtractor;
- sp<FFmpegExtractor> mExtractor;
+ FFmpegExtractor *mExtractor;
size_t mTrackIndex;
enum AVMediaType mMediaType;
////////////////////////////////////////////////////////////////////////////////
-FFmpegExtractor::FFmpegExtractor(
const sp<DataSource> &source, const sp<AMessage> &meta)
+FFmpegExtractor::FFmpegExtractor(
DataSourceBase *source, const sp<AMessage> &meta)
: mDataSource(source),
- mMeta(new MetaData),
mInitCheck(NO_INIT),
mFormatCtx(NULL),
mReaderThreadStarted(false),
return mInitCheck == OK ? mTracks.size() : 0;
}
-sp<IMediaSource> FFmpegExtractor::getTrack(size_t index) {
+MediaTrack* FFmpegExtractor::getTrack(size_t index) {
ALOGV("FFmpegExtractor::getTrack[%zu]", index);
if (mInitCheck != OK) {
return new FFmpegSource(this, index);
}
-sp<MetaData> FFmpegExtractor::getTrackMetaData(size_t index, uint32_t flags __unused) {
+status_t FFmpegExtractor::getTrackMetaData(MetaDataBase &meta, size_t index, uint32_t flags __unused) {
ALOGV("FFmpegExtractor::getTrackMetaData[%zu]", index);
if (mInitCheck != OK) {
- return NULL;
+ return UNKNOWN_ERROR;
}
if (index >= mTracks.size()) {
- return NULL;
+ return UNKNOWN_ERROR;
}
/* Quick and dirty, just get a frame 1/4 in */
if (mTracks.itemAt(index).mIndex == mVideoStreamIdx &&
mFormatCtx->duration != AV_NOPTS_VALUE) {
- mTracks.itemAt(index).mMeta->setInt64(
+ mTracks.editItemAt(index).mMeta.setInt64(
kKeyThumbnailTime, mFormatCtx->duration / 4);
}
- return mTracks.itemAt(index).mMeta;
+ meta = mTracks.itemAt(index).mMeta;
+ return OK;
}
-sp<MetaData> FFmpegExtractor::getMetaData() {
+status_t FFmpegExtractor::getMetaData(MetaDataBase &meta) {
ALOGV("FFmpegExtractor::getMetaData");
if (mInitCheck != OK) {
- return NULL;
+ return UNKNOWN_ERROR;
}
if (!mParsedMetadata) {
mParsedMetadata = true;
}
- return mMeta;
+ meta = mMeta;
+ return OK;
}
uint32_t FFmpegExtractor::flags() const {
return supported;
}
-sp<MetaData> FFmpegExtractor::setVideoFormat(AVStream *stream)
+status_t FFmpegExtractor::setVideoFormat(AVStream *stream, MetaDataBase &meta)
{
AVCodecContext *avctx = NULL;
- sp<MetaData> meta = NULL;
+ status_t ret = UNKNOWN_ERROR;
avctx = stream->codec;
CHECK_EQ((int)avctx->codec_type, (int)AVMEDIA_TYPE_VIDEO);
switch(avctx->codec_id) {
case AV_CODEC_ID_H264:
if (avctx->extradata[0] == 1) {
- meta = setAVCFormat(avctx);
+ ret = setAVCFormat(avctx, meta);
} else {
- meta = setH264Format(avctx);
+ ret = setH264Format(avctx, meta);
}
break;
case AV_CODEC_ID_MPEG4:
- meta = setMPEG4Format(avctx);
+ ret = setMPEG4Format(avctx, meta);
break;
case AV_CODEC_ID_H263:
case AV_CODEC_ID_H263P:
case AV_CODEC_ID_H263I:
- meta = setH263Format(avctx);
+ ret = setH263Format(avctx, meta);
break;
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
- meta = setMPEG2VIDEOFormat(avctx);
+ ret = setMPEG2VIDEOFormat(avctx, meta);
break;
case AV_CODEC_ID_VC1:
- meta = setVC1Format(avctx);
+ ret = setVC1Format(avctx, meta);
break;
case AV_CODEC_ID_WMV1:
- meta = setWMV1Format(avctx);
+ ret = setWMV1Format(avctx, meta);
break;
case AV_CODEC_ID_WMV2:
- meta = setWMV2Format(avctx);
+ ret = setWMV2Format(avctx, meta);
break;
case AV_CODEC_ID_WMV3:
- meta = setWMV3Format(avctx);
+ ret = setWMV3Format(avctx, meta);
break;
case AV_CODEC_ID_RV20:
- meta = setRV20Format(avctx);
+ ret = setRV20Format(avctx, meta);
break;
case AV_CODEC_ID_RV30:
- meta = setRV30Format(avctx);
+ ret = setRV30Format(avctx, meta);
break;
case AV_CODEC_ID_RV40:
- meta = setRV40Format(avctx);
+ ret = setRV40Format(avctx, meta);
break;
case AV_CODEC_ID_FLV1:
- meta = setFLV1Format(avctx);
+ ret = setFLV1Format(avctx, meta);
break;
case AV_CODEC_ID_HEVC:
- meta = setHEVCFormat(avctx);
+ ret = setHEVCFormat(avctx, meta);
break;
case AV_CODEC_ID_VP8:
- meta = setVP8Format(avctx);
+ ret = setVP8Format(avctx, meta);
break;
case AV_CODEC_ID_VP9:
- meta = setVP9Format(avctx);
+ ret = setVP9Format(avctx, meta);
break;
default:
ALOGD("unsupported video codec (id: %d, name: %s), but give it a chance",
avctx->codec_id, avcodec_get_name(avctx->codec_id));
- meta = new MetaData;
- meta->setInt32(kKeyCodecId, avctx->codec_id);
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FFMPEG);
+ meta.setInt32(kKeyCodecId, avctx->codec_id);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FFMPEG);
if (avctx->extradata_size > 0) {
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
}
//CHECK(!"Should not be here. Unsupported codec.");
break;
}
- if (meta != NULL) {
+ if (ret == OK) {
// rotation
double theta = get_rotation(stream);
int rotationDegrees = 0;
rotationDegrees = 270;
}
if (rotationDegrees != 0) {
- meta->setInt32(kKeyRotation, rotationDegrees);
+ meta.setInt32(kKeyRotation, rotationDegrees);
}
}
- if (meta != NULL) {
+ if (ret == OK) {
float aspect_ratio;
int width, height;
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);
+ meta.setInt32(kKeyWidth, avctx->width);
+ meta.setInt32(kKeyHeight, avctx->height);
if ((width > 0) && (height > 0) &&
((avctx->width != width || avctx->height != height))) {
- meta->setInt32(kKeySARWidth, width);
- meta->setInt32(kKeySARHeight, height);
+ meta.setInt32(kKeySARWidth, width);
+ meta.setInt32(kKeySARHeight, height);
ALOGI("SAR width: %d, SAR height: %d", width, height);
}
if (avctx->bit_rate > 0) {
- meta->setInt32(kKeyBitRate, avctx->bit_rate);
+ meta.setInt32(kKeyBitRate, avctx->bit_rate);
}
- meta->setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
+ meta.setCString('ffmt', findMatchingContainer(mFormatCtx->iformat->name));
setDurationMetaData(stream, meta);
}
- return meta;
+ return OK;
}
-sp<MetaData> FFmpegExtractor::setAudioFormat(AVStream *stream)
+status_t FFmpegExtractor::setAudioFormat(AVStream *stream, MetaDataBase &meta)
{
AVCodecContext *avctx = NULL;
- sp<MetaData> meta = NULL;
+ status_t ret = UNKNOWN_ERROR;
avctx = stream->codec;
CHECK_EQ((int)avctx->codec_type, (int)AVMEDIA_TYPE_AUDIO);
switch(avctx->codec_id) {
case AV_CODEC_ID_MP2:
- meta = setMP2Format(avctx);
+ ret = setMP2Format(avctx, meta);
break;
case AV_CODEC_ID_MP3:
- meta = setMP3Format(avctx);
+ ret = setMP3Format(avctx, meta);
break;
case AV_CODEC_ID_VORBIS:
- meta = setVORBISFormat(avctx);
+ ret = setVORBISFormat(avctx, meta);
break;
case AV_CODEC_ID_AC3:
- meta = setAC3Format(avctx);
+ ret = setAC3Format(avctx, meta);
break;
case AV_CODEC_ID_AAC:
- meta = setAACFormat(avctx);
+ ret = setAACFormat(avctx, meta);
break;
case AV_CODEC_ID_WMAV1:
- meta = setWMAV1Format(avctx);
+ ret = setWMAV1Format(avctx, meta);
break;
case AV_CODEC_ID_WMAV2:
- meta = setWMAV2Format(avctx);
+ ret = setWMAV2Format(avctx, meta);
break;
case AV_CODEC_ID_WMAPRO:
- meta = setWMAProFormat(avctx);
+ ret = setWMAProFormat(avctx, meta);
break;
case AV_CODEC_ID_WMALOSSLESS:
- meta = setWMALossLessFormat(avctx);
+ ret = setWMALossLessFormat(avctx, meta);
break;
case AV_CODEC_ID_COOK:
- meta = setRAFormat(avctx);
+ ret = setRAFormat(avctx, meta);
break;
case AV_CODEC_ID_APE:
- meta = setAPEFormat(avctx);
+ ret = setAPEFormat(avctx, meta);
break;
case AV_CODEC_ID_DTS:
- meta = setDTSFormat(avctx);
+ ret = setDTSFormat(avctx, meta);
break;
case AV_CODEC_ID_FLAC:
- meta = setFLACFormat(avctx);
+ ret = setFLACFormat(avctx, meta);
break;
case AV_CODEC_ID_ALAC:
- meta = setALACFormat(avctx);
+ ret = setALACFormat(avctx, meta);
break;
default:
ALOGD("unsupported audio codec (id: %d, name: %s), but give it a chance",
avctx->codec_id, avcodec_get_name(avctx->codec_id));
- meta = new MetaData;
- meta->setInt32(kKeyCodecId, avctx->codec_id);
- meta->setInt32(kKeyCodedSampleBits, avctx->bits_per_coded_sample);
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FFMPEG);
+ meta.setInt32(kKeyCodecId, avctx->codec_id);
+ meta.setInt32(kKeyCodedSampleBits, avctx->bits_per_coded_sample);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FFMPEG);
if (avctx->extradata_size > 0) {
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
}
//CHECK(!"Should not be here. Unsupported codec.");
break;
}
- if (meta != NULL) {
+ if (ret == 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",
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);
+ meta.setInt32(kKeyChannelCount, avctx->channels);
+ meta.setInt32(kKeyBitRate, 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));
+ 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));
setDurationMetaData(stream, meta);
}
- return meta;
+ return OK;
}
-void FFmpegExtractor::setDurationMetaData(AVStream *stream, sp<MetaData> &meta)
+void FFmpegExtractor::setDurationMetaData(AVStream *stream, MetaDataBase &meta)
{
AVCodecContext *avctx = stream->codec;
} else {
ALOGV("%s startTime:N/A", s);
}
- meta->setInt64(kKeyDuration, duration);
+ meta.setInt64(kKeyDuration, duration);
} else {
// default when no stream duration
- meta->setInt64(kKeyDuration, mFormatCtx->duration);
+ meta.setInt64(kKeyDuration, mFormatCtx->duration);
}
}
{
TrackInfo *trackInfo = NULL;
AVCodecContext *avctx = NULL;
- sp<MetaData> meta = NULL;
bool supported = false;
- uint32_t type = 0;
- const void *data = NULL;
- size_t size = 0;
int ret = 0;
ALOGI("stream_index: %d", stream_index);
}
ALOGI("support the codec(%s) disposition(%x)", avcodec_get_name(avctx->codec_id), mFormatCtx->streams[stream_index]->disposition);
- unsigned streamType;
for (size_t i = 0; i < mTracks.size(); ++i) {
if (stream_index == mTracks.editItemAt(i).mIndex) {
ALOGE("this track already exists");
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;
+
switch (avctx->codec_type) {
case AVMEDIA_TYPE_VIDEO:
if (mVideoStreamIdx == -1)
ALOGV("video stream no extradata, but we can ignore it.");
}
#endif
- meta = setVideoFormat(mVideoStream);
- if (meta == NULL) {
+ if (setVideoFormat(mVideoStream, meta) != OK) {
ALOGE("setVideoFormat failed");
return -1;
}
ALOGV("audio stream no extradata, but we can ignore it.");
}
#endif
- meta = setAudioFormat(mAudioStream);
- if (meta == NULL) {
+ if (setAudioFormat(mAudioStream, meta) != OK) {
ALOGE("setAudioFormat failed");
return -1;
}
//mime
CHECK(meta->findString("extended-extractor-mime", &mime));
CHECK(mime.c_str() != NULL);
- mMeta->setCString(kKeyMIMEType, mime.c_str());
+ mMeta.setCString(kKeyMIMEType, mime.c_str());
}
void FFmpegExtractor::setFFmpegDefaultOpts()
{
int err = 0;
int i = 0;
- int eof = 0;
int ret = 0, audio_ret = -1, video_ret = -1;
- int pkt_in_play_range = 0;
AVDictionaryEntry *t = NULL;
AVDictionary **opts = NULL;
int orig_nb_streams = 0;
wanted_stream[AVMEDIA_TYPE_AUDIO] = -1;
wanted_stream[AVMEDIA_TYPE_VIDEO] = -1;
AVDictionary *format_opts = NULL, *codec_opts = NULL;
- const char *mime = NULL;
setFFmpegDefaultOpts();
}
void FFmpegExtractor::readerEntry() {
- int err, i, ret;
+ int ret;
AVPacket pkt1, *pkt = &pkt1;
int eof = 0;
- int pkt_in_play_range = 0;
mLock.lock();
////////////////////////////////////////////////////////////////////////////////
FFmpegSource::FFmpegSource(
- const sp<FFmpegExtractor> &extractor, size_t index)
+ FFmpegExtractor *extractor, size_t index)
: mExtractor(extractor),
mTrackIndex(index),
mIsAVC(false),
mQueue(mExtractor->mTracks.itemAt(index).mQueue),
mLastPTS(AV_NOPTS_VALUE),
mTargetTime(AV_NOPTS_VALUE) {
- sp<MetaData> meta = mExtractor->mTracks.itemAt(index).mMeta;
+ const MetaDataBase& meta = mExtractor->mTracks.itemAt(index).mMeta;
{
AVCodecContext *avctx = mStream->codec;
uint32_t type;
const void *data;
size_t size;
- CHECK(meta->findData(kKeyAVCC, &type, &data, &size));
+ CHECK(meta.findData(kKeyAVCC, &type, &data, &size));
const uint8_t *ptr = (const uint8_t *)data;
uint32_t type;
const void *data;
size_t size;
- CHECK(meta->findData(kKeyHVCC, &type, &data, &size));
+ CHECK(meta.findData(kKeyHVCC, &type, &data, &size));
const uint8_t *ptr = (const uint8_t *)data;
mExtractor = NULL;
}
-status_t FFmpegSource::start(MetaData * /* params */) {
+status_t FFmpegSource::start(MetaDataBase * /* params */) {
ALOGV("FFmpegSource::start %s",
av_get_media_type_string(mMediaType));
return OK;
return OK;
}
-sp<MetaData> FFmpegSource::getFormat() {
- return mExtractor->mTracks.itemAt(mTrackIndex).mMeta;;
+status_t FFmpegSource::getFormat(MetaDataBase &meta) {
+ meta = mExtractor->mTracks.itemAt(mTrackIndex).mMeta;
+ return OK;
}
status_t FFmpegSource::read(
- MediaBuffer **buffer, const ReadOptions *options) {
+ MediaBufferBase **buffer, const ReadOptions *options) {
*buffer = NULL;
AVPacket pkt;
}
MediaBuffer *mediaBuffer = new MediaBuffer(pkt.size + AV_INPUT_BUFFER_PADDING_SIZE);
- mediaBuffer->meta_data()->clear();
+ mediaBuffer->meta_data().clear();
mediaBuffer->set_range(0, pkt.size);
//copy data
av_get_media_type_string(mMediaType), pkt.size, key);
#endif
- mediaBuffer->meta_data()->setInt64(kKeyTime, timeUs);
- mediaBuffer->meta_data()->setInt32(kKeyIsSyncFrame, key);
+ mediaBuffer->meta_data().setInt64(kKeyTime, timeUs);
+ mediaBuffer->meta_data().setInt32(kKeyIsSyncFrame, 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);
+ mediaBuffer->meta_data().setInt64(kKeyTargetTime, seekTimeUs);
}
if (mTargetTime != AV_NOPTS_VALUE) {
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);
+ mediaBuffer->meta_data().setInt64(kKeyTime, mTargetTime);
mTargetTime = AV_NOPTS_VALUE;
}
}
static bool hasAudioCodecOnly(AVFormatContext *ic)
{
- enum AVCodecID codec_id = AV_CODEC_ID_NONE;
bool haveVideo = false;
bool haveAudio = false;
return container;
}
-static const char *BetterSniffFFMPEG(const sp<DataSource> &source,
- float *confidence, sp<AMessage> meta)
+static const char *BetterSniffFFMPEG(DataSourceBase *source,
+ float *confidence, AMessage *meta)
{
const char *ret = NULL;
char url[PATH_MAX] = {0};
- ALOGI("android-source:%p", source.get());
+ ALOGI("android-source:%p", source);
// pass the addr of smart pointer("source")
- snprintf(url, sizeof(url), "android-source:%p", source.get());
+ snprintf(url, sizeof(url), "android-source:%p", source);
ret = SniffFFMPEGCommon(url, confidence,
(source->flags() & DataSource::kIsCachingDataSource));
return ret;
}
-static const char *LegacySniffFFMPEG(const sp<DataSource> &source,
- float *confidence, sp<AMessage> meta)
+static const char *LegacySniffFFMPEG(DataSourceBase *source,
+ float *confidence, AMessage *meta)
{
const char *ret = NULL;
+ char uri[PATH_MAX] = {0};
char url[PATH_MAX] = {0};
- String8 uri = source->getUri();
- if (!uri.string()) {
+ if (!source->getUri(uri, sizeof(uri))) {
return NULL;
}
if (source->flags() & DataSource::kIsCachingDataSource)
return NULL;
- ALOGV("source url:%s", uri.string());
+ ALOGV("source url:%s", uri);
// pass the addr of smart pointer("source") + file name
- snprintf(url, sizeof(url), "android-source:%p|file:%s", source.get(), uri.string());
+ snprintf(url, sizeof(url), "android-source:%p|file:%s", source, uri);
ret = SniffFFMPEGCommon(url, confidence, false);
if (ret) {
return ret;
}
-extern "C" {
+static void FreeMeta(void *meta) {
+ if (meta != nullptr) {
+ static_cast<AMessage *>(meta)->decStrong(nullptr);
+ }
+}
-bool SniffFFMPEG(
- const sp<DataSource> &source, String8 *mimeType, float *confidence,
- sp<AMessage> *meta) {
+static MediaExtractor::CreatorFunc
+SniffFFMPEG(
+ DataSourceBase *source, float *confidence, void **meta,
+ MediaExtractor::FreeMetaFunc *freeMeta) {
float newConfidence = 0.08f;
- ALOGV("SniffFFMPEG (initial confidence: %f, mime: %s)", *confidence,
- mimeType == NULL ? "unknown" : *mimeType);
+ ALOGV("SniffFFMPEG (initial confidence: %f)", *confidence);
// This is a heavyweight sniffer, don't invoke it if Stagefright knows
// what it is doing already.
- if (mimeType != NULL && confidence != NULL) {
- if (*mimeType == "application/ogg") {
- return false;
- }
+ if (confidence != NULL) {
if (*confidence > 0.8f) {
- return false;
+ return NULL;
}
}
- *meta = new AMessage;
+ AMessage *msg = new AMessage;
+
+ *meta = msg;
+ *freeMeta = FreeMeta;
+ msg->incStrong(nullptr);
- const char *container = BetterSniffFFMPEG(source, &newConfidence, *meta);
+ const char *container = BetterSniffFFMPEG(source, &newConfidence, msg);
if (!container) {
ALOGW("sniff through BetterSniffFFMPEG failed, try LegacySniffFFMPEG");
- container = LegacySniffFFMPEG(source, &newConfidence, *meta);
+ container = LegacySniffFFMPEG(source, &newConfidence, msg);
if (container) {
ALOGV("sniff through LegacySniffFFMPEG success");
}
if (container == NULL) {
ALOGD("SniffFFMPEG failed to sniff this source");
- (*meta)->clear();
+ msg->decStrong(nullptr);
*meta = NULL;
- return false;
+ *freeMeta = NULL;
+ return NULL;
}
ALOGD("ffmpeg detected media content as '%s' with confidence %.2f",
container, newConfidence);
- mimeType->setTo(container);
-
- (*meta)->setString("extended-extractor", "extended-extractor");
- (*meta)->setString("extended-extractor-subtype", "ffmpegextractor");
- (*meta)->setString("extended-extractor-mime", container);
+ msg->setString("extended-extractor", "extended-extractor");
+ msg->setString("extended-extractor-subtype", "ffmpegextractor");
+ msg->setString("extended-extractor-mime", container);
//debug only
char value[PROPERTY_VALUE_MAX];
}
if (newConfidence > *confidence) {
- (*meta)->setString("extended-extractor-use", "ffmpegextractor");
+ msg->setString("extended-extractor-use", "ffmpegextractor");
*confidence = newConfidence;
}
- return true;
+ return CreateFFMPEGExtractor;
}
-MediaExtractor *CreateFFMPEGExtractor(const sp<DataSource> &source, const char *mime, const sp<AMessage> &meta) {
+static MediaExtractor *CreateFFMPEGExtractor(DataSourceBase *source, void *meta) {
MediaExtractor *ret = NULL;
- AString notuse;
- if (meta.get() && meta->findString("extended-extractor", ¬use) && (
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_VORBIS) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_ALAC) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AC3) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_APE) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_DTS) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RA) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_WMA) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FFMPEG) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG4) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MOV) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MATROSKA) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_TS) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_AVI) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_ASF) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WEBM) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMV) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPG) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLV) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DIVX) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RM) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WAV) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FLAC) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_APE) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_DTS) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MP2) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_RA) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_OGG) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_VC1) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_HEVC) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WMA) ||
- !strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_FFMPEG))) {
- ret = new FFmpegExtractor(source, meta);
- }
-
- ALOGD("%ssupported mime: %s", (ret ? "" : "un"), mime);
+ sp<AMessage> msg = static_cast<AMessage *>(meta);
+ AString mime;
+ if (msg.get() && msg->findString("extended-extractor-mime", &mime) && (
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_MPEG) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AAC) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_VORBIS) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_ALAC) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_FLAC) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_AC3) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_APE) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_DTS) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_RA) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_WMA) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_AUDIO_FFMPEG) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MPEG4) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MOV) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MATROSKA) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_TS) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MPEG2PS) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_AVI) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_ASF) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WEBM) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WMV) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MPG) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_FLV) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_DIVX) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_RM) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_WAV) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_FLAC) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_APE) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_DTS) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_MP2) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_RA) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_OGG) ||
+ !strcasecmp(mime.c_str(), MEDIA_MIMETYPE_CONTAINER_VC1) ||
+ !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);
+ }
+
+ ALOGD("%ssupported mime: %s", (ret ? "" : "un"), mime.c_str());
return ret;
}
+extern "C" {
+
+__attribute__ ((visibility ("default")))
+MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
+ return {
+ MediaExtractor::EXTRACTORDEF_VERSION,
+ UUID("280e1e71-d08b-4d8c-ba03-d775497fc4bc"),
+ 1, // version
+ "FFMPEG Extractor",
+ SniffFFMPEG
+ };
+}
+
}
}; // namespace android
#include <utils/Errors.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 "include/avc_utils.h"
+#include <media/stagefright/MetaDataUtils.h>
#include "codec_utils.h"
//http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
// H.264 bitstream without start codes.
-sp<MetaData> setAVCFormat(AVCodecContext *avctx)
+status_t setAVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("AVC");
avctx->height = height;
}
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
- meta->setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
+ meta.setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
// H.264 bitstream with start codes.
-sp<MetaData> setH264Format(AVCodecContext *avctx)
+status_t setH264Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("H264");
CHECK_NE((int)avctx->extradata[0], 1); //configurationVersion
- sp<ABuffer> buffer = new ABuffer(avctx->extradata_size);
- memcpy(buffer->data(), avctx->extradata, avctx->extradata_size);
- return MakeAVCCodecSpecificData(buffer);
+ if (!MakeAVCCodecSpecificData(meta, avctx->extradata, avctx->extradata_size))
+ return UNKNOWN_ERROR;
+
+ return OK;
}
-sp<MetaData> setMPEG4Format(AVCodecContext *avctx)
+status_t setMPEG4Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("MPEG4");
memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
- sp<MetaData> meta = new MetaData;
- meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
+ meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
int divxVersion = getDivXVersion(avctx);
if (divxVersion >= 0) {
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
- meta->setInt32(kKeyDivXVersion, divxVersion);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
+ meta.setInt32(kKeyDivXVersion, divxVersion);
} else {
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
}
- return meta;
+ return OK;
}
-sp<MetaData> setH263Format(AVCodecContext *avctx __unused)
+status_t setH263Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
{
ALOGV("H263");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
- return meta;
+ return OK;
}
-sp<MetaData> setMPEG2VIDEOFormat(AVCodecContext *avctx)
+status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("MPEG%uVIDEO", avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 2 : 1);
memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
- sp<MetaData> meta = new MetaData;
- meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
+ meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
- return meta;
+ return OK;
}
-sp<MetaData> setVC1Format(AVCodecContext *avctx)
+status_t setVC1Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("VC1");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
-sp<MetaData> setWMV1Format(AVCodecContext *avctx __unused)
+status_t setWMV1Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
{
ALOGV("WMV1");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
- meta->setInt32(kKeyWMVVersion, kTypeWMVVer_7);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
+ meta.setInt32(kKeyWMVVersion, kTypeWMVVer_7);
- return meta;
+ return OK;
}
-sp<MetaData> setWMV2Format(AVCodecContext *avctx)
+status_t setWMV2Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("WMV2");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- meta->setInt32(kKeyWMVVersion, kTypeWMVVer_8);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setInt32(kKeyWMVVersion, kTypeWMVVer_8);
- return meta;
+ return OK;
}
-sp<MetaData> setWMV3Format(AVCodecContext *avctx)
+status_t setWMV3Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("WMV3");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- meta->setInt32(kKeyWMVVersion, kTypeWMVVer_9);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setInt32(kKeyWMVVersion, kTypeWMVVer_9);
- return meta;
+ return OK;
}
-sp<MetaData> setRV20Format(AVCodecContext *avctx)
+status_t setRV20Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("RV20");
- sp<MetaData> meta = new MetaData;
- 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
+ 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
- return meta;
+ return OK;
}
-sp<MetaData> setRV30Format(AVCodecContext *avctx)
+status_t setRV30Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("RV30");
- sp<MetaData> meta = new MetaData;
- 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
+ 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
- return meta;
+ return OK;
}
-sp<MetaData> setRV40Format(AVCodecContext *avctx)
+status_t setRV40Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("RV40");
- sp<MetaData> meta = new MetaData;
- 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
+ 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
- return meta;
+ return OK;
}
-sp<MetaData> setFLV1Format(AVCodecContext *avctx)
+status_t setFLV1Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("FLV1(Sorenson H263)");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
-sp<MetaData> setHEVCFormat(AVCodecContext *avctx)
+status_t setHEVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("HEVC");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
- meta->setData(kKeyHVCC, kTypeHVCC, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
+ meta.setData(kKeyHVCC, kTypeHVCC, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
-sp<MetaData> setVP8Format(AVCodecContext *avctx __unused)
+status_t setVP8Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
{
ALOGV("VP8");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
- return meta;
+ return OK;
}
-sp<MetaData> setVP9Format(AVCodecContext *avctx __unused)
+status_t setVP9Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
{
ALOGV("VP9");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
- return meta;
+ return OK;
}
//audio
-sp<MetaData> setMP2Format(AVCodecContext *avctx __unused)
+status_t setMP2Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
{
ALOGV("MP2");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
- return meta;
+ return OK;
}
-sp<MetaData> setMP3Format(AVCodecContext *avctx __unused)
+status_t setMP3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
{
ALOGV("MP3");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
- return meta;
+ return OK;
}
-sp<MetaData> setVORBISFormat(AVCodecContext *avctx)
+status_t setVORBISFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("VORBIS");
avctx->extradata_size, 30,
header_start, header_len) < 0) {
ALOGE("vorbis extradata corrupt.");
- return NULL;
+ return UNKNOWN_ERROR;
}
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
//identification header
- meta->setData(kKeyVorbisInfo, 0, header_start[0], header_len[0]);
+ meta.setData(kKeyVorbisInfo, 0, header_start[0], header_len[0]);
//setup header
- meta->setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
+ meta.setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
- return meta;
+ return OK;
}
-sp<MetaData> setAC3Format(AVCodecContext *avctx __unused)
+status_t setAC3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
{
ALOGV("AC3");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
- return meta;
+ return OK;
}
-sp<MetaData> setAACFormat(AVCodecContext *avctx)
+status_t setAACFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("AAC");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- meta->setInt32(kKeyAACAOT, avctx->profile + 1);
- return meta;
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setInt32(kKeyAACAOT, avctx->profile + 1);
+
+ return OK;
}
-sp<MetaData> setWMAV1Format(AVCodecContext *avctx)
+status_t setWMAV1Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("WMAV1");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- meta->setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
- return meta;
+ return OK;
}
-sp<MetaData> setWMAV2Format(AVCodecContext *avctx)
+status_t setWMAV2Format(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("WMAV2");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- meta->setInt32(kKeyWMAVersion, kTypeWMA);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setInt32(kKeyWMAVersion, kTypeWMA);
- return meta;
+ return OK;
}
-sp<MetaData> setWMAProFormat(AVCodecContext *avctx)
+status_t setWMAProFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("WMAPro");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- meta->setInt32(kKeyWMAVersion, kTypeWMAPro);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setInt32(kKeyWMAVersion, kTypeWMAPro);
- return meta;
+ return OK;
}
-sp<MetaData> setWMALossLessFormat(AVCodecContext *avctx)
+status_t setWMALossLessFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("WMALOSSLESS");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- meta->setInt32(kKeyWMAVersion, kTypeWMALossLess);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setInt32(kKeyWMAVersion, kTypeWMALossLess);
- return meta;
+ return OK;
}
-sp<MetaData> setRAFormat(AVCodecContext *avctx)
+status_t setRAFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("COOK");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
-sp<MetaData> setALACFormat(AVCodecContext *avctx)
+status_t setALACFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("ALAC");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_ALAC);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_ALAC);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
-sp<MetaData> setAPEFormat(AVCodecContext *avctx)
+status_t setAPEFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("APE");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
-sp<MetaData> setDTSFormat(AVCodecContext *avctx)
+status_t setDTSFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("DTS");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
- return meta;
+ return OK;
}
-sp<MetaData> setFLACFormat(AVCodecContext *avctx)
+status_t setFLACFormat(AVCodecContext *avctx, MetaDataBase &meta)
{
ALOGV("FLAC");
- sp<MetaData> meta = new MetaData;
- meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
- meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
+ meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
+ meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
if (avctx->extradata_size < 10) {
ALOGE("Invalid extradata in FLAC file! (size=%d)", avctx->extradata_size);
- return meta;
+ return UNKNOWN_ERROR;
}
ABitReader br(avctx->extradata, avctx->extradata_size);
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);
+ meta.setInt32('mibs', minBlockSize);
+ meta.setInt32('mabs', maxBlockSize);
+ meta.setInt32('mifs', minFrameSize);
+ meta.setInt32('mafs', maxFrameSize);
- return meta;
+ return OK;
}
//Convert H.264 NAL format to annex b
return -1;
}
-status_t parseMetadataTags(AVFormatContext *ctx, const sp<MetaData> &meta) {
- if (meta == NULL || ctx == NULL) {
+status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta) {
+ if (ctx == NULL) {
return NO_INIT;
}
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);
+ meta.setCString(kMap[i].to, entry->value);
}
}
}
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);
+ meta.setData(kKeyAlbumArt, MetaData::TYPE_NONE, pkt.data, pkt.size);
+ meta.setCString(kKeyAlbumArtMIME, mime);
}
}
}
OSDN Git Service
