Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge change 7954

Browse Source 
* changes:
  Added native metadata support.
This commit is contained in:
Android (Google) Code Review
2009-07-22 15:26:02 -07:00
parent 2c33bb19f7 bc72692780
commit ddbf560cfb
14 changed files with 359 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
include/media/MediaPlayerInterface.h
View File

@@ -26,11 +26,10 @@
#include <media/mediaplayer.h>
#include <media/AudioSystem.h>
#include <media/Metadata.h>
namespace android {
typedef int32_t MetadataType;
class Parcel;
template<typename T> class SortedVector;
@@ -129,8 +128,10 @@ public:
// the known metadata should be returned.
// @param[inout] records Parcel where the player appends its metadata.
// @return OK if the call was successful.
virtual status_t getMetadata(const SortedVector<MetadataType>& ids,
Parcel *records) = 0;
virtual status_t getMetadata(const media::Metadata::Filter& ids,
Parcel *records) {
return INVALID_OPERATION;
};
protected:
virtual void sendEvent(int msg, int ext1=0, int ext2=0) { if (mNotify) mNotify(mCookie, msg, ext1, ext2); }

133
include/media/Metadata.h Normal file
View File

@@ -0,0 +1,133 @@
/*
* 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.
*/
#ifndef ANDROID_MEDIA_METADATA_H__
#define ANDROID_MEDIA_METADATA_H__
#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
#include <utils/SortedVector.h>
namespace android {
class Parcel;
namespace media {
// Metadata is a class to build/serialize a set of metadata in a Parcel.
//
// This class should be kept in sync with android/media/Metadata.java.
// It provides all the metadata ids available and methods to build the
// header, add records and adjust the set size header field.
//
// Typical Usage:
// ==============
// Parcel p;
// media::Metadata data(&p);
//
// data.appendHeader();
// data.appendBool(Metadata::kPauseAvailable, true);
// ... more append ...
// data.updateLength();
//
class Metadata {
public:
typedef int32_t Type;
typedef SortedVector<Type> Filter;
static const Type kAny = 0;
// Keep in sync with android/media/Metadata.java
static const Type kTitle = 1; // String
static const Type kComment = 2; // String
static const Type kCopyright = 3; // String
static const Type kAlbum = 4; // String
static const Type kArtist = 5; // String
static const Type kAuthor = 6; // String
static const Type kComposer = 7; // String
static const Type kGenre = 8; // String
static const Type kDate = 9; // Date
static const Type kDuration = 10; // Integer(millisec)
static const Type kCdTrackNum = 11; // Integer 1-based
static const Type kCdTrackMax = 12; // Integer
static const Type kRating = 13; // String
static const Type kAlbumArt = 14; // byte[]
static const Type kVideoFrame = 15; // Bitmap
static const Type kCaption = 16; // TimedText
static const Type kBitRate = 17; // Integer, Aggregate rate of
// all the streams in bps.
static const Type kAudioBitRate = 18; // Integer, bps
static const Type kVideoBitRate = 19; // Integer, bps
static const Type kAudioSampleRate = 20; // Integer, Hz
static const Type kVideoframeRate = 21; // Integer, Hz
// See RFC2046 and RFC4281.
static const Type kMimeType = 22; // String
static const Type kAudioCodec = 23; // String
static const Type kVideoCodec = 24; // String
static const Type kVideoHeight = 25; // Integer
static const Type kVideoWidth = 26; // Integer
static const Type kNumTracks = 27; // Integer
static const Type kDrmCrippled = 28; // Boolean
// Playback capabilities.
static const Type kPauseAvailable = 29; // Boolean
static const Type kSeekBackwardAvailable = 30; // Boolean
static const Type kSeekForwardAvailable = 31; // Boolean
// @param p[inout] The parcel to append the metadata records
// to. The global metadata header should have been set already.
explicit Metadata(Parcel *p);
~Metadata();
// Rewind the underlying parcel, undoing all the changes.
void resetParcel();
// Append the size and 'META' marker.
bool appendHeader();
// Once all the records have been added, call this to update the
// lenght field in the header.
void updateLength();
// append* are methods to append metadata.
// @param key Is the metadata Id.
// @param val Is the value of the metadata.
// @return true if successful, false otherwise.
// TODO: add more as needed to handle other types.
bool appendBool(Type key, bool val);
bool appendInt32(Type key, int32_t val);
private:
Metadata(const Metadata&);
Metadata& operator=(const Metadata&);
// Checks the key is valid and not already present.
bool checkKey(Type key);
Parcel *mData;
size_t mBegin;
};
} // namespace android::media
} // namespace android
#endif // ANDROID_MEDIA_METADATA_H__

6
include/media/PVPlayer.h
View File

@@ -19,6 +19,7 @@
#include <utils/Errors.h>
#include <media/MediaPlayerInterface.h>
#include <media/Metadata.h>
#define MAX_OPENCORE_INSTANCES 25
@@ -53,8 +54,9 @@ public:
virtual status_t setLooping(int loop);
virtual player_type playerType() { return PV_PLAYER; }
virtual status_t invoke(const Parcel& request, Parcel *reply);
virtual status_t getMetadata(const SortedVector<MetadataType>& ids,
Parcel *records);
virtual status_t getMetadata(
const SortedVector<media::Metadata::Type>& ids,
Parcel *records);
// make available to PlayerDriver
void sendEvent(int msg, int ext1=0, int ext2=0) { MediaPlayerBase::sendEvent(msg, ext1, ext2); }

2
media/java/android/media/Metadata.java
View File

@@ -104,7 +104,7 @@ public class Metadata
public static final int SEEK_FORWARD_AVAILABLE = 31; // Boolean
private static final int LAST_SYSTEM = 31;
private static final int FIRST_CUSTOM = 8092;
private static final int FIRST_CUSTOM = 8192;
// Shorthands to set the MediaPlayer's metadata filter.
public static final Set<Integer> MATCH_NONE = Collections.EMPTY_SET;

37
media/libmedia/Android.mk
View File

@@ -2,24 +2,25 @@ LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
AudioTrack.cpp \
IAudioFlinger.cpp \
IAudioFlingerClient.cpp \
IAudioTrack.cpp \
IAudioRecord.cpp \
AudioRecord.cpp \
AudioSystem.cpp \
mediaplayer.cpp \
IMediaPlayerService.cpp \
IMediaPlayerClient.cpp \
IMediaPlayer.cpp \
IMediaRecorder.cpp \
mediarecorder.cpp \
IMediaMetadataRetriever.cpp \
mediametadataretriever.cpp \
ToneGenerator.cpp \
JetPlayer.cpp \
IOMX.cpp
AudioTrack.cpp \
IAudioFlinger.cpp \
IAudioFlingerClient.cpp \
IAudioTrack.cpp \
IAudioRecord.cpp \
AudioRecord.cpp \
AudioSystem.cpp \
mediaplayer.cpp \
IMediaPlayerService.cpp \
IMediaPlayerClient.cpp \
IMediaPlayer.cpp \
IMediaRecorder.cpp \
Metadata.cpp \
mediarecorder.cpp \
IMediaMetadataRetriever.cpp \
mediametadataretriever.cpp \
ToneGenerator.cpp \
JetPlayer.cpp \
IOMX.cpp
LOCAL_SHARED_LIBRARIES := \
libui libcutils libutils libbinder libsonivox

168
media/libmedia/Metadata.cpp Normal file
View File

@@ -0,0 +1,168 @@
/*
* 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 "Metadata"
#include <utils/Log.h>
#include <sys/types.h>
#include <media/Metadata.h>
#include <binder/Parcel.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
// This file contains code to serialize Metadata triples (key, type,
// value) into a parcel. The Parcel is destinated to be decoded by the
// Metadata.java class.
namespace {
// All these constants below must be kept in sync with Metadata.java.
enum MetadataId {
FIRST_SYSTEM_ID = 1,
LAST_SYSTEM_ID = 31,
FIRST_CUSTOM_ID = 8192
};
// Types
enum Types {
STRING_VAL = 1,
INTEGER_VAL,
BOOLEAN_VAL,
LONG_VAL,
DOUBLE_VAL,
TIMED_TEXT_VAL,
DATE_VAL,
BYTE_ARRAY_VAL,
};
const size_t kRecordHeaderSize = 3 * sizeof(int32_t);
const int32_t kMetaMarker = 0x4d455441; // 'M' 'E' 'T' 'A'
} // anonymous namespace
namespace android {
namespace media {
Metadata::Metadata(Parcel *p)
:mData(p),
mBegin(p->dataPosition()) { }
Metadata::~Metadata() { }
void Metadata::resetParcel()
{
mData->setDataPosition(mBegin);
}
// Update the 4 bytes int at the beginning of the parcel which holds
// the number of bytes written so far.
void Metadata::updateLength()
{
const size_t end = mData->dataPosition();
mData->setDataPosition(mBegin);
mData->writeInt32(end - mBegin);
mData->setDataPosition(end);
}
// Write the header. The java layer will look for the marker.
bool Metadata::appendHeader()
{
bool ok = true;
// Placeholder for the length of the metadata
ok = ok && mData->writeInt32(-1) == OK;
ok = ok && mData->writeInt32(kMetaMarker) == OK;
return ok;
}
bool Metadata::appendBool(int key, bool val)
{
if (!checkKey(key)) {
return false;
}
const size_t begin = mData->dataPosition();
bool ok = true;
// 4 int32s: size, key, type, value.
ok = ok && mData->writeInt32(4 * sizeof(int32_t)) == OK;
ok = ok && mData->writeInt32(key) == OK;
ok = ok && mData->writeInt32(BOOLEAN_VAL) == OK;
ok = ok && mData->writeInt32(val ? 1 : 0) == OK;
if (!ok) {
mData->setDataPosition(begin);
}
return ok;
}
bool Metadata::appendInt32(int key, int32_t val)
{
if (!checkKey(key)) {
return false;
}
const size_t begin = mData->dataPosition();
bool ok = true;
// 4 int32s: size, key, type, value.
ok = ok && mData->writeInt32(4 * sizeof(int32_t)) == OK;
ok = ok && mData->writeInt32(key) == OK;
ok = ok && mData->writeInt32(INTEGER_VAL) == OK;
ok = ok && mData->writeInt32(val) == OK;
if (!ok) {
mData->setDataPosition(begin);
}
return ok;
}
// Check the key (i.e metadata id) is valid if it is a system one.
// Loop over all the exiting ones in the Parcel to check for duplicate
// (not allowed).
bool Metadata::checkKey(int key)
{
if (key < FIRST_SYSTEM_ID ||
(LAST_SYSTEM_ID < key && key < FIRST_CUSTOM_ID)) {
LOGE("Bad key %d", key);
return false;
}
size_t curr = mData->dataPosition();
// Loop over the keys to check if it has been used already.
mData->setDataPosition(mBegin);
bool error = false;
size_t left = curr - mBegin;
while (left > 0) {
size_t pos = mData->dataPosition();
size_t size = mData->readInt32();
if (size < kRecordHeaderSize || size > left) {
error = true;
break;
}
if (mData->readInt32() == key) {
LOGE("Key exists already %d", key);
error = true;
break;
}
mData->setDataPosition(pos + size);
left -= size;
}
mData->setDataPosition(curr);
return !error;
}
} // namespace android::media
} // namespace android

53
media/libmediaplayerservice/MediaPlayerService.cpp
View File

@@ -47,10 +47,9 @@
#include <media/MediaPlayerInterface.h>
#include <media/mediarecorder.h>
#include <media/MediaMetadataRetrieverInterface.h>
#include <media/Metadata.h>
#include <media/AudioTrack.h>
#include <utils/SortedVector.h>
#include "MediaRecorderClient.h"
#include "MediaPlayerService.h"
#include "MetadataRetrieverClient.h"
@@ -85,21 +84,17 @@ pid_t gettid() { return syscall(__NR_gettid);}
#endif
namespace {
using android::media::Metadata;
using android::status_t;
using android::OK;
using android::BAD_VALUE;
using android::NOT_ENOUGH_DATA;
using android::MetadataType;
using android::Parcel;
using android::SortedVector;
// Max number of entries in the filter.
const int kMaxFilterSize = 64; // I pulled that out of thin air.
// Keep in sync with ANY in Metadata.java
const int32_t kAny = 0;
const int32_t kMetaMarker = 0x4d455441; // 'M' 'E' 'T' 'A'
// FIXME: Move all the metadata related function in the Metadata.cpp
// Unmarshall a filter from a Parcel.
@@ -124,7 +119,7 @@ const int32_t kMetaMarker = 0x4d455441; // 'M' 'E' 'T' 'A'
// @param[out] status On exit contains the status code to be returned.
// @return true if the parcel starts with a valid filter.
bool unmarshallFilter(const Parcel& p,
SortedVector<MetadataType> *filter,
Metadata::Filter *filter,
status_t *status)
{
int32_t val;
@@ -147,7 +142,7 @@ bool unmarshallFilter(const Parcel& p,
filter->clear();
filter->setCapacity(num);
size_t size = num * sizeof(MetadataType);
size_t size = num * sizeof(Metadata::Type);
if (p.dataAvail() < size)
@@ -157,7 +152,8 @@ bool unmarshallFilter(const Parcel& p,
return false;
}
const MetadataType *data = static_cast<const MetadataType*>(p.readInplace(size));
const Metadata::Type *data =
static_cast<const Metadata::Type*>(p.readInplace(size));
if (NULL == data)
{
@@ -181,11 +177,11 @@ bool unmarshallFilter(const Parcel& p,
// @param filter Of metadata type.
// @param val To be searched.
// @return true if a match was found.
bool findMetadata(const SortedVector<MetadataType>& filter, const int32_t val)
bool findMetadata(const Metadata::Filter& filter, const int32_t val)
{
// Deal with empty and ANY right away
if (filter.isEmpty()) return false;
if (filter[0] == kAny) return true;
if (filter[0] == Metadata::kAny) return true;
return filter.indexOf(val) >= 0;
}
@@ -857,7 +853,7 @@ status_t MediaPlayerService::Client::invoke(const Parcel& request,
status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
{
status_t status;
SortedVector<MetadataType> allow, drop;
media::Metadata::Filter allow, drop;
if (unmarshallFilter(filter, &allow, &status) &&
unmarshallFilter(filter, &drop, &status)) {
@@ -872,14 +868,14 @@ status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
status_t MediaPlayerService::Client::getMetadata(
bool update_only, bool apply_filter, Parcel *reply)
{
sp<MediaPlayerBase> p = getPlayer();
if (p == 0) return UNKNOWN_ERROR;
sp<MediaPlayerBase> player = getPlayer();
if (player == 0) return UNKNOWN_ERROR;
status_t status;
// Placeholder for the return code, updated by the caller.
reply->writeInt32(-1);
SortedVector<MetadataType> ids;
media::Metadata::Filter ids;
// We don't block notifications while we fetch the data. We clear
// mMetadataUpdated first so we don't lose notifications happening
@@ -892,14 +888,13 @@ status_t MediaPlayerService::Client::getMetadata(
mMetadataUpdated.clear();
}
const size_t begin = reply->dataPosition();
reply->writeInt32(-1); // Placeholder for the length of the metadata
reply->writeInt32(kMetaMarker);
media::Metadata metadata(reply);
status = p->getMetadata(ids, reply);
metadata.appendHeader();
status = player->getMetadata(ids, reply);
if (status != OK) {
reply->setDataPosition(begin);
metadata.resetParcel();
LOGE("getMetadata failed %d", status);
return status;
}
@@ -908,12 +903,8 @@ status_t MediaPlayerService::Client::getMetadata(
// filtering takes place on the update notifications already. This
// would be when all the metadata are fetch and a filter is set.
const size_t end = reply->dataPosition();
// Everything is fine, update the metadata length.
reply->setDataPosition(begin);
reply->writeInt32(end - begin);
reply->setDataPosition(end);
metadata.updateLength();
return OK;
}
@@ -1043,7 +1034,7 @@ void MediaPlayerService::Client::notify(void* cookie, int msg, int ext1, int ext
if (MEDIA_INFO == msg &&
MEDIA_INFO_METADATA_UPDATE == ext1) {
const MetadataType metadata_type = ext2;
const media::Metadata::Type metadata_type = ext2;
if(client->shouldDropMetadata(metadata_type)) {
return;
@@ -1058,7 +1049,7 @@ void MediaPlayerService::Client::notify(void* cookie, int msg, int ext1, int ext
}
bool MediaPlayerService::Client::shouldDropMetadata(MetadataType code) const
bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
{
Mutex::Autolock lock(mLock);
@@ -1074,7 +1065,7 @@ bool MediaPlayerService::Client::shouldDropMetadata(MetadataType code) const
}
void MediaPlayerService::Client::addNewMetadataUpdate(MetadataType metadata_type) {
void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
Mutex::Autolock lock(mLock);
if (mMetadataUpdated.indexOf(metadata_type) < 0) {
mMetadataUpdated.add(metadata_type);
@@ -1499,4 +1490,4 @@ void MediaPlayerService::AudioCache::notify(void* cookie, int msg, int ext1, int
p->mSignal.signal();
}
}; // namespace android
} // namespace android

13
media/libmediaplayerservice/MediaPlayerService.h
View File

@@ -23,15 +23,14 @@
#include <utils/List.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/SortedVector.h>
#include <utils/Vector.h>
#include <ui/SurfaceComposerClient.h>
#include <media/IMediaPlayerService.h>
#include <media/MediaPlayerInterface.h>
#include <media/Metadata.h>
namespace android {
typedef int32_t MetadataType;
class IMediaRecorder;
class IMediaMetadataRetriever;
@@ -239,12 +238,12 @@ private:
// @param type Of the metadata to be tested.
// @return true if the metadata should be dropped according to
// the filters.
bool shouldDropMetadata(MetadataType type) const;
bool shouldDropMetadata(media::Metadata::Type type) const;
// Add a new element to the set of metadata updated. Noop if
// the element exists already.
// @param type Of the metadata to be recorded.
void addNewMetadataUpdate(MetadataType type);
void addNewMetadataUpdate(media::Metadata::Type type);
mutable Mutex mLock;
sp<MediaPlayerBase> mPlayer;
@@ -257,14 +256,14 @@ private:
int32_t mConnId;
// Metadata filters.
SortedVector<int32_t> mMetadataAllow; // protected by mLock
SortedVector<int32_t> mMetadataDrop; // protected by mLock
media::Metadata::Filter mMetadataAllow; // protected by mLock
media::Metadata::Filter mMetadataDrop; // protected by mLock
// Metadata updated. For each MEDIA_INFO_METADATA_UPDATE
// notification we try to update mMetadataUpdated which is a
// set: no duplicate.
// getMetadata clears this set.
SortedVector<int32_t> mMetadataUpdated; // protected by mLock
media::Metadata::Filter mMetadataUpdated; // protected by mLock
#if CALLBACK_ANTAGONIZER
Antagonizer* mAntagonizer;

4
media/libmediaplayerservice/MidiFile.h
View File

@@ -49,10 +49,6 @@ public:
virtual status_t invoke(const Parcel& request, Parcel *reply) {
return INVALID_OPERATION;
}
virtual status_t getMetadata(const SortedVector<MetadataType>& ids,
Parcel *records) {
return INVALID_OPERATION;
}
private:
status_t createOutputTrack();

7
media/libmediaplayerservice/StagefrightPlayer.cpp
View File

@@ -144,7 +144,7 @@ status_t StagefrightPlayer::seekTo(int msec) {
if (mPlayer == NULL) {
return NO_INIT;
}
status_t err = mPlayer->seekTo((int64_t)msec * 1000);
sendEvent(MEDIA_SEEK_COMPLETE);
@@ -205,9 +205,4 @@ void StagefrightPlayer::setAudioSink(const sp<AudioSink> &audioSink) {
}
}
status_t StagefrightPlayer::getMetadata(
const SortedVector<MetadataType> &ids, Parcel *records) {
return INVALID_OPERATION;
}
} // namespace android

3
media/libmediaplayerservice/StagefrightPlayer.h
View File

@@ -48,9 +48,6 @@ public:
virtual status_t invoke(const Parcel &request, Parcel *reply);
virtual void setAudioSink(const sp<AudioSink> &audioSink);
virtual status_t getMetadata(
const SortedVector<MetadataType> &ids, Parcel *records);
private:
MediaPlayerImpl *mPlayer;

4
media/libmediaplayerservice/TestPlayerStub.h
View File

@@ -94,10 +94,6 @@ class TestPlayerStub : public MediaPlayerInterface {
virtual status_t invoke(const android::Parcel& in, android::Parcel *out) {
return mPlayer->invoke(in, out);
}
virtual status_t getMetadata(const SortedVector<MetadataType>& ids,
Parcel *records) {
return INVALID_OPERATION;
}
// @return true if the current build is 'eng' or 'test' and the

4
media/libmediaplayerservice/VorbisPlayer.h
View File

@@ -54,10 +54,6 @@ public:
virtual status_t setLooping(int loop);
virtual player_type playerType() { return VORBIS_PLAYER; }
virtual status_t invoke(const Parcel& request, Parcel *reply) {return INVALID_OPERATION;}
virtual status_t getMetadata(const SortedVector<MetadataType>& ids,
Parcel *records) {
return INVALID_OPERATION;
}
private:
status_t setdatasource(const char *path, int fd, int64_t offset, int64_t length);

3
media/tests/players/invoke_mock_media_player.cpp
View File

@@ -27,7 +27,6 @@
using android::INVALID_OPERATION;
using android::ISurface;
using android::MediaPlayerBase;
using android::MetadataType;
using android::OK;
using android::Parcel;
using android::SortedVector;
@@ -78,8 +77,6 @@ class Player: public MediaPlayerBase
virtual status_t setLooping(int loop) {return OK;}
virtual player_type playerType() {return TEST_PLAYER;}
virtual status_t invoke(const Parcel& request, Parcel *reply);
virtual status_t getMetadata(const SortedVector<MetadataType>& ids,
Parcel *records) {return INVALID_OPERATION;}
private:
// Take a request, copy it to the reply.