blob: a2f3f134fb075256fac011deaade118de070a36f [file] [log] [blame]
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "StagefrightMetadataRetriever"
#include <utils/Log.h>
#include "include/StagefrightMetadataRetriever.h"
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/ColorConverter.h>
#include <media/stagefright/DataSource.h>
#include <media/stagefright/FileSource.h>
#include <media/stagefright/MediaExtractor.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/OMXCodec.h>
#include <media/stagefright/MediaDefs.h>
namespace android {
StagefrightMetadataRetriever::StagefrightMetadataRetriever()
: mParsedMetaData(false),
mAlbumArt(NULL) {
ALOGV("StagefrightMetadataRetriever()");
DataSource::RegisterDefaultSniffers();
CHECK_EQ(mClient.connect(), (status_t)OK);
}
StagefrightMetadataRetriever::~StagefrightMetadataRetriever() {
ALOGV("~StagefrightMetadataRetriever()");
delete mAlbumArt;
mAlbumArt = NULL;
mClient.disconnect();
}
status_t StagefrightMetadataRetriever::setDataSource(
const char *uri, const KeyedVector<String8, String8> *headers) {
ALOGV("setDataSource(%s)", uri);
mParsedMetaData = false;
mMetaData.clear();
delete mAlbumArt;
mAlbumArt = NULL;
mSource = DataSource::CreateFromURI(uri, headers);
if (mSource == NULL) {
ALOGE("Unable to create data source for '%s'.", uri);
return UNKNOWN_ERROR;
}
mExtractor = MediaExtractor::Create(mSource);
if (mExtractor == NULL) {
ALOGE("Unable to instantiate an extractor for '%s'.", uri);
mSource.clear();
return UNKNOWN_ERROR;
}
return OK;
}
// Warning caller retains ownership of the filedescriptor! Dup it if necessary.
status_t StagefrightMetadataRetriever::setDataSource(
int fd, int64_t offset, int64_t length) {
fd = dup(fd);
ALOGV("setDataSource(%d, %lld, %lld)", fd, offset, length);
mParsedMetaData = false;
mMetaData.clear();
delete mAlbumArt;
mAlbumArt = NULL;
mSource = new FileSource(fd, offset, length);
status_t err;
if ((err = mSource->initCheck()) != OK) {
mSource.clear();
return err;
}
mExtractor = MediaExtractor::Create(mSource);
if (mExtractor == NULL) {
mSource.clear();
return UNKNOWN_ERROR;
}
return OK;
}
static bool isYUV420PlanarSupported(
OMXClient *client,
const sp<MetaData> &trackMeta) {
const char *mime;
CHECK(trackMeta->findCString(kKeyMIMEType, &mime));
Vector<CodecCapabilities> caps;
if (QueryCodecs(client->interface(), mime,
true, /* queryDecoders */
true, /* hwCodecOnly */
&caps) == OK) {
for (size_t j = 0; j < caps.size(); ++j) {
CodecCapabilities cap = caps[j];
for (size_t i = 0; i < cap.mColorFormats.size(); ++i) {
if (cap.mColorFormats[i] == OMX_COLOR_FormatYUV420Planar) {
return true;
}
}
}
}
return false;
}
static VideoFrame *extractVideoFrameWithCodecFlags(
OMXClient *client,
const sp<MetaData> &trackMeta,
const sp<MediaSource> &source,
uint32_t flags,
int64_t frameTimeUs,
int seekMode) {
sp<MetaData> format = source->getFormat();
// XXX:
// Once all vendors support OMX_COLOR_FormatYUV420Planar, we can
// remove this check and always set the decoder output color format
if (isYUV420PlanarSupported(client, trackMeta)) {
format->setInt32(kKeyColorFormat, OMX_COLOR_FormatYUV420Planar);
}
sp<MediaSource> decoder =
OMXCodec::Create(
client->interface(), format, false, source,
NULL, flags | OMXCodec::kClientNeedsFramebuffer);
if (decoder.get() == NULL) {
ALOGV("unable to instantiate video decoder.");
return NULL;
}
status_t err = decoder->start();
if (err != OK) {
ALOGW("OMXCodec::start returned error %d (0x%08x)\n", err, err);
return NULL;
}
// Read one output buffer, ignore format change notifications
// and spurious empty buffers.
MediaSource::ReadOptions options;
if (seekMode < MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC ||
seekMode > MediaSource::ReadOptions::SEEK_CLOSEST) {
ALOGE("Unknown seek mode: %d", seekMode);
return NULL;
}
MediaSource::ReadOptions::SeekMode mode =
static_cast<MediaSource::ReadOptions::SeekMode>(seekMode);
int64_t thumbNailTime;
if (frameTimeUs < 0) {
if (!trackMeta->findInt64(kKeyThumbnailTime, &thumbNailTime)
|| thumbNailTime < 0) {
thumbNailTime = 0;
}
options.setSeekTo(thumbNailTime, mode);
} else {
thumbNailTime = -1;
options.setSeekTo(frameTimeUs, mode);
}
MediaBuffer *buffer = NULL;
do {
if (buffer != NULL) {
buffer->release();
buffer = NULL;
}
err = decoder->read(&buffer, &options);
options.clearSeekTo();
} while (err == INFO_FORMAT_CHANGED
|| (buffer != NULL && buffer->range_length() == 0));
if (err != OK) {
CHECK(buffer == NULL);
ALOGV("decoding frame failed.");
decoder->stop();
return NULL;
}
ALOGV("successfully decoded video frame.");
int32_t unreadable;
if (buffer->meta_data()->findInt32(kKeyIsUnreadable, &unreadable)
&& unreadable != 0) {
ALOGV("video frame is unreadable, decoder does not give us access "
"to the video data.");
buffer->release();
buffer = NULL;
decoder->stop();
return NULL;
}
int64_t timeUs;
CHECK(buffer->meta_data()->findInt64(kKeyTime, &timeUs));
if (thumbNailTime >= 0) {
if (timeUs != thumbNailTime) {
const char *mime;
CHECK(trackMeta->findCString(kKeyMIMEType, &mime));
ALOGV("thumbNailTime = %lld us, timeUs = %lld us, mime = %s",
thumbNailTime, timeUs, mime);
}
}
sp<MetaData> meta = decoder->getFormat();
int32_t width, height;
CHECK(meta->findInt32(kKeyWidth, &width));
CHECK(meta->findInt32(kKeyHeight, &height));
int32_t crop_left, crop_top, crop_right, crop_bottom;
if (!meta->findRect(
kKeyCropRect,
&crop_left, &crop_top, &crop_right, &crop_bottom)) {
crop_left = crop_top = 0;
crop_right = width - 1;
crop_bottom = height - 1;
}
int32_t rotationAngle;
if (!trackMeta->findInt32(kKeyRotation, &rotationAngle)) {
rotationAngle = 0; // By default, no rotation
}
VideoFrame *frame = new VideoFrame;
frame->mWidth = crop_right - crop_left + 1;
frame->mHeight = crop_bottom - crop_top + 1;
frame->mDisplayWidth = frame->mWidth;
frame->mDisplayHeight = frame->mHeight;
frame->mSize = frame->mWidth * frame->mHeight * 2;
frame->mData = new uint8_t[frame->mSize];
frame->mRotationAngle = rotationAngle;
int32_t displayWidth, displayHeight;
if (meta->findInt32(kKeyDisplayWidth, &displayWidth)) {
frame->mDisplayWidth = displayWidth;
}
if (meta->findInt32(kKeyDisplayHeight, &displayHeight)) {
frame->mDisplayHeight = displayHeight;
}
int32_t srcFormat;
CHECK(meta->findInt32(kKeyColorFormat, &srcFormat));
ColorConverter converter(
(OMX_COLOR_FORMATTYPE)srcFormat, OMX_COLOR_Format16bitRGB565);
if (converter.isValid()) {
err = converter.convert(
(const uint8_t *)buffer->data() + buffer->range_offset(),
width, height,
crop_left, crop_top, crop_right, crop_bottom,
frame->mData,
frame->mWidth,
frame->mHeight,
0, 0, frame->mWidth - 1, frame->mHeight - 1);
} else {
ALOGE("Unable to instantiate color conversion from format 0x%08x to "
"RGB565",
srcFormat);
err = ERROR_UNSUPPORTED;
}
buffer->release();
buffer = NULL;
decoder->stop();
if (err != OK) {
ALOGE("Colorconverter failed to convert frame.");
delete frame;
frame = NULL;
}
return frame;
}
VideoFrame *StagefrightMetadataRetriever::getFrameAtTime(
int64_t timeUs, int option) {
ALOGV("getFrameAtTime: %lld us option: %d", timeUs, option);
if (mExtractor.get() == NULL) {
ALOGV("no extractor.");
return NULL;
}
sp<MetaData> fileMeta = mExtractor->getMetaData();
if (fileMeta == NULL) {
ALOGV("extractor doesn't publish metadata, failed to initialize?");
return NULL;
}
int32_t drm = 0;
if (fileMeta->findInt32(kKeyIsDRM, &drm) && drm != 0) {
ALOGE("frame grab not allowed.");
return NULL;
}
size_t n = mExtractor->countTracks();
size_t i;
for (i = 0; i < n; ++i) {
sp<MetaData> meta = mExtractor->getTrackMetaData(i);
const char *mime;
CHECK(meta->findCString(kKeyMIMEType, &mime));
if (!strncasecmp(mime, "video/", 6)) {
break;
}
}
if (i == n) {
ALOGV("no video track found.");
return NULL;
}
sp<MetaData> trackMeta = mExtractor->getTrackMetaData(
i, MediaExtractor::kIncludeExtensiveMetaData);
sp<MediaSource> source = mExtractor->getTrack(i);
if (source.get() == NULL) {
ALOGV("unable to instantiate video track.");
return NULL;
}
const void *data;
uint32_t type;
size_t dataSize;
if (fileMeta->findData(kKeyAlbumArt, &type, &data, &dataSize)
&& mAlbumArt == NULL) {
mAlbumArt = new MediaAlbumArt;
mAlbumArt->mSize = dataSize;
mAlbumArt->mData = new uint8_t[dataSize];
memcpy(mAlbumArt->mData, data, dataSize);
}
VideoFrame *frame =
extractVideoFrameWithCodecFlags(
&mClient, trackMeta, source, OMXCodec::kPreferSoftwareCodecs,
timeUs, option);
if (frame == NULL) {
ALOGV("Software decoder failed to extract thumbnail, "
"trying hardware decoder.");
frame = extractVideoFrameWithCodecFlags(&mClient, trackMeta, source, 0,
timeUs, option);
}
return frame;
}
MediaAlbumArt *StagefrightMetadataRetriever::extractAlbumArt() {
ALOGV("extractAlbumArt (extractor: %s)", mExtractor.get() != NULL ? "YES" : "NO");
if (mExtractor == NULL) {
return NULL;
}
if (!mParsedMetaData) {
parseMetaData();
mParsedMetaData = true;
}
if (mAlbumArt) {
return new MediaAlbumArt(*mAlbumArt);
}
return NULL;
}
const char *StagefrightMetadataRetriever::extractMetadata(int keyCode) {
if (mExtractor == NULL) {
return NULL;
}
if (!mParsedMetaData) {
parseMetaData();
mParsedMetaData = true;
}
ssize_t index = mMetaData.indexOfKey(keyCode);
if (index < 0) {
return NULL;
}
return strdup(mMetaData.valueAt(index).string());
}
void StagefrightMetadataRetriever::parseMetaData() {
sp<MetaData> meta = mExtractor->getMetaData();
if (meta == NULL) {
ALOGV("extractor doesn't publish metadata, failed to initialize?");
return;
}
struct Map {
int from;
int to;
};
static const Map kMap[] = {
{ kKeyMIMEType, METADATA_KEY_MIMETYPE },
{ kKeyCDTrackNumber, METADATA_KEY_CD_TRACK_NUMBER },
{ kKeyDiscNumber, METADATA_KEY_DISC_NUMBER },
{ kKeyAlbum, METADATA_KEY_ALBUM },
{ kKeyArtist, METADATA_KEY_ARTIST },
{ kKeyAlbumArtist, METADATA_KEY_ALBUMARTIST },
{ kKeyAuthor, METADATA_KEY_AUTHOR },
{ kKeyComposer, METADATA_KEY_COMPOSER },
{ kKeyDate, METADATA_KEY_DATE },
{ kKeyGenre, METADATA_KEY_GENRE },
{ kKeyTitle, METADATA_KEY_TITLE },
{ kKeyYear, METADATA_KEY_YEAR },
{ kKeyWriter, METADATA_KEY_WRITER },
{ kKeyCompilation, METADATA_KEY_COMPILATION },
{ kKeyLocation, METADATA_KEY_LOCATION },
};
static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
for (size_t i = 0; i < kNumMapEntries; ++i) {
const char *value;
if (meta->findCString(kMap[i].from, &value)) {
mMetaData.add(kMap[i].to, String8(value));
}
}
const void *data;
uint32_t type;
size_t dataSize;
if (meta->findData(kKeyAlbumArt, &type, &data, &dataSize)
&& mAlbumArt == NULL) {
mAlbumArt = new MediaAlbumArt;
mAlbumArt->mSize = dataSize;
mAlbumArt->mData = new uint8_t[dataSize];
memcpy(mAlbumArt->mData, data, dataSize);
}
size_t numTracks = mExtractor->countTracks();
char tmp[32];
sprintf(tmp, "%d", numTracks);
mMetaData.add(METADATA_KEY_NUM_TRACKS, String8(tmp));
bool hasAudio = false;
bool hasVideo = false;
int32_t videoWidth = -1;
int32_t videoHeight = -1;
int32_t audioBitrate = -1;
int32_t rotationAngle = -1;
// The overall duration is the duration of the longest track.
int64_t maxDurationUs = 0;
String8 timedTextLang;
for (size_t i = 0; i < numTracks; ++i) {
sp<MetaData> trackMeta = mExtractor->getTrackMetaData(i);
int64_t durationUs;
if (trackMeta->findInt64(kKeyDuration, &durationUs)) {
if (durationUs > maxDurationUs) {
maxDurationUs = durationUs;
}
}
const char *mime;
if (trackMeta->findCString(kKeyMIMEType, &mime)) {
if (!hasAudio && !strncasecmp("audio/", mime, 6)) {
hasAudio = true;
if (!trackMeta->findInt32(kKeyBitRate, &audioBitrate)) {
audioBitrate = -1;
}
} else if (!hasVideo && !strncasecmp("video/", mime, 6)) {
hasVideo = true;
CHECK(trackMeta->findInt32(kKeyWidth, &videoWidth));
CHECK(trackMeta->findInt32(kKeyHeight, &videoHeight));
if (!trackMeta->findInt32(kKeyRotation, &rotationAngle)) {
rotationAngle = 0;
}
} else if (!strcasecmp(mime, MEDIA_MIMETYPE_TEXT_3GPP)) {
const char *lang;
trackMeta->findCString(kKeyMediaLanguage, &lang);
timedTextLang.append(String8(lang));
timedTextLang.append(String8(":"));
}
}
}
// To save the language codes for all timed text tracks
// If multiple text tracks present, the format will look
// like "eng:chi"
if (!timedTextLang.isEmpty()) {
mMetaData.add(METADATA_KEY_TIMED_TEXT_LANGUAGES, timedTextLang);
}
// The duration value is a string representing the duration in ms.
sprintf(tmp, "%lld", (maxDurationUs + 500) / 1000);
mMetaData.add(METADATA_KEY_DURATION, String8(tmp));
if (hasAudio) {
mMetaData.add(METADATA_KEY_HAS_AUDIO, String8("yes"));
}
if (hasVideo) {
mMetaData.add(METADATA_KEY_HAS_VIDEO, String8("yes"));
sprintf(tmp, "%d", videoWidth);
mMetaData.add(METADATA_KEY_VIDEO_WIDTH, String8(tmp));
sprintf(tmp, "%d", videoHeight);
mMetaData.add(METADATA_KEY_VIDEO_HEIGHT, String8(tmp));
sprintf(tmp, "%d", rotationAngle);
mMetaData.add(METADATA_KEY_VIDEO_ROTATION, String8(tmp));
}
if (numTracks == 1 && hasAudio && audioBitrate >= 0) {
sprintf(tmp, "%d", audioBitrate);
mMetaData.add(METADATA_KEY_BITRATE, String8(tmp));
} else {
off64_t sourceSize;
if (mSource->getSize(&sourceSize) == OK) {
int64_t avgBitRate = (int64_t)(sourceSize * 8E6 / maxDurationUs);
sprintf(tmp, "%lld", avgBitRate);
mMetaData.add(METADATA_KEY_BITRATE, String8(tmp));
}
}
if (numTracks == 1) {
const char *fileMIME;
CHECK(meta->findCString(kKeyMIMEType, &fileMIME));
if (!strcasecmp(fileMIME, "video/x-matroska")) {
sp<MetaData> trackMeta = mExtractor->getTrackMetaData(0);
const char *trackMIME;
CHECK(trackMeta->findCString(kKeyMIMEType, &trackMIME));
if (!strncasecmp("audio/", trackMIME, 6)) {
// The matroska file only contains a single audio track,
// rewrite its mime type.
mMetaData.add(
METADATA_KEY_MIMETYPE, String8("audio/x-matroska"));
}
}
}
// To check whether the media file is drm-protected
if (mExtractor->getDrmFlag()) {
mMetaData.add(METADATA_KEY_IS_DRM, String8("1"));
}
}
} // namespace android