Merge "AudioPolicyManager: fix offload playback for speaker and BT"
diff --git a/media/extractors/mp4/ItemTable.cpp b/media/extractors/mp4/ItemTable.cpp
index 7816473..eb6602c 100644
--- a/media/extractors/mp4/ItemTable.cpp
+++ b/media/extractors/mp4/ItemTable.cpp
@@ -1687,8 +1687,31 @@
}
// skip the first 4-byte of the offset to TIFF header
- *offset = mItemIdToExifMap[exifIndex].offset + 4;
- *size = mItemIdToExifMap[exifIndex].size - 4;
+ uint32_t tiffOffset;
+ if (!mDataSource->readAt(
+ mItemIdToExifMap[exifIndex].offset, &tiffOffset, 4)) {
+ return ERROR_IO;
+ }
+
+ // We need 'Exif\0\0' before the tiff header
+ tiffOffset = ntohl(tiffOffset);
+ if (tiffOffset < 6) {
+ return ERROR_MALFORMED;
+ }
+ // The first 4-byte of the item is the offset of the tiff header within the
+ // exif data. The size of the item should be > 4 for a non-empty exif (this
+ // was already checked when the item was added). Also check that the tiff
+ // header offset is valid.
+ if (mItemIdToExifMap[exifIndex].size <= 4 ||
+ tiffOffset > mItemIdToExifMap[exifIndex].size - 4) {
+ return ERROR_MALFORMED;
+ }
+
+ // Offset of 'Exif\0\0' relative to the beginning of 'Exif' item
+ // (first 4-byte is the tiff header offset)
+ uint32_t exifOffset = 4 + tiffOffset - 6;
+ *offset = mItemIdToExifMap[exifIndex].offset + exifOffset;
+ *size = mItemIdToExifMap[exifIndex].size - exifOffset;
return OK;
}
diff --git a/media/extractors/mp4/MPEG4Extractor.cpp b/media/extractors/mp4/MPEG4Extractor.cpp
index 50f172e..d0efddd 100644
--- a/media/extractors/mp4/MPEG4Extractor.cpp
+++ b/media/extractors/mp4/MPEG4Extractor.cpp
@@ -6048,6 +6048,7 @@
// Just give these file types a chance.
FOURCC("qt "), // Apple's QuickTime
FOURCC("MSNV"), // Sony's PSP
+ FOURCC("wmf "),
FOURCC("3g2a"), // 3GPP2
FOURCC("3g2b"),
diff --git a/media/libmediametrics/Android.bp b/media/libmediametrics/Android.bp
index e188e54..15ea578 100644
--- a/media/libmediametrics/Android.bp
+++ b/media/libmediametrics/Android.bp
@@ -1,6 +1,4 @@
-// TODO: change it back to cc_library_shared when there is a way to
-// expose media metrics as stable API.
-cc_library {
+cc_library_shared {
name: "libmediametrics",
srcs: [
@@ -32,12 +30,13 @@
cfi: true,
},
- // enumerate the stable interface
-// this would mean nobody can use the C++ interface. have to rework some things.
-// stubs: {
-// symbol_file: "libmediametrics.map.txt",
-// versions: [
-// "1" ,
-// ]
-// },
+ // enumerate stable entry points, for apex use
+ stubs: {
+ symbol_file: "libmediametrics.map.txt",
+ versions: [
+ "1" ,
+ ]
+ },
}
+
+
diff --git a/media/libmediametrics/IMediaAnalyticsService.cpp b/media/libmediametrics/IMediaAnalyticsService.cpp
index 28a7746..9114927 100644
--- a/media/libmediametrics/IMediaAnalyticsService.cpp
+++ b/media/libmediametrics/IMediaAnalyticsService.cpp
@@ -142,7 +142,7 @@
CHECK_INTERFACE(IMediaAnalyticsService, data, reply);
bool forcenew;
- MediaAnalyticsItem *item = new MediaAnalyticsItem;
+ MediaAnalyticsItem *item = MediaAnalyticsItem::create();
data.readBool(&forcenew);
item->readFromParcel(data);
diff --git a/media/libmediametrics/MediaAnalyticsItem.cpp b/media/libmediametrics/MediaAnalyticsItem.cpp
index 448e2d9..02c23b1 100644
--- a/media/libmediametrics/MediaAnalyticsItem.cpp
+++ b/media/libmediametrics/MediaAnalyticsItem.cpp
@@ -52,6 +52,17 @@
const char * const MediaAnalyticsItem::EnabledPropertyPersist = "persist.media.metrics.enabled";
const int MediaAnalyticsItem::EnabledProperty_default = 1;
+// So caller doesn't need to know size of allocated space
+MediaAnalyticsItem *MediaAnalyticsItem::create()
+{
+ return MediaAnalyticsItem::create(kKeyNone);
+}
+
+MediaAnalyticsItem *MediaAnalyticsItem::create(MediaAnalyticsItem::Key key)
+{
+ MediaAnalyticsItem *item = new MediaAnalyticsItem(key);
+ return item;
+}
// access functions for the class
MediaAnalyticsItem::MediaAnalyticsItem()
@@ -642,6 +653,19 @@
//
int32_t MediaAnalyticsItem::readFromParcel(const Parcel& data) {
+ int32_t version = data.readInt32();
+
+ switch(version) {
+ case 0:
+ return readFromParcel0(data);
+ break;
+ default:
+ ALOGE("Unsupported MediaAnalyticsItem Parcel version: %d", version);
+ return -1;
+ }
+}
+
+int32_t MediaAnalyticsItem::readFromParcel0(const Parcel& data) {
// into 'this' object
// .. we make a copy of the string to put away.
mKey = data.readCString();
@@ -691,8 +715,23 @@
}
int32_t MediaAnalyticsItem::writeToParcel(Parcel *data) {
+
if (data == NULL) return -1;
+ int32_t version = 0;
+ data->writeInt32(version);
+
+ switch(version) {
+ case 0:
+ return writeToParcel0(data);
+ break;
+ default:
+ ALOGE("Unsupported MediaAnalyticsItem Parcel version: %d", version);
+ return -1;
+ }
+}
+
+int32_t MediaAnalyticsItem::writeToParcel0(Parcel *data) {
data->writeCString(mKey.c_str());
data->writeInt32(mPid);
@@ -737,7 +776,6 @@
return 0;
}
-
const char *MediaAnalyticsItem::toCString() {
return toCString(PROTO_LAST);
}
@@ -876,8 +914,6 @@
}
return true;
} else {
- std::string p = this->toString();
- ALOGW("Unable to record: %s [forcenew=%d]", p.c_str(), forcenew);
return false;
}
}
@@ -1035,5 +1071,170 @@
return true;
}
+// a byte array; contents are
+// overall length (uint32) including the length field itself
+// encoding version (uint32)
+// count of properties (uint32)
+// N copies of:
+// property name as length(int16), bytes
+// the bytes WILL include the null terminator of the name
+// type (uint8 -- 1 byte)
+// size of value field (int16 -- 2 bytes)
+// value (size based on type)
+// int32, int64, double -- little endian 4/8/8 bytes respectively
+// cstring -- N bytes of value [WITH terminator]
+
+enum { kInt32 = 0, kInt64, kDouble, kRate, kCString};
+
+bool MediaAnalyticsItem::dumpAttributes(char **pbuffer, size_t *plength) {
+
+ char *build = NULL;
+
+ if (pbuffer == NULL || plength == NULL)
+ return false;
+
+ // consistency for the caller, who owns whatever comes back in this pointer.
+ *pbuffer = NULL;
+
+ // first, let's calculate sizes
+ int32_t goal = 0;
+ int32_t version = 0;
+
+ goal += sizeof(uint32_t); // overall length, including the length field
+ goal += sizeof(uint32_t); // encoding version
+ goal += sizeof(uint32_t); // # properties
+
+ int32_t count = mPropCount;
+ for (int i = 0 ; i < count; i++ ) {
+ Prop *prop = &mProps[i];
+ goal += sizeof(uint16_t); // name length
+ goal += strlen(prop->mName) + 1; // string + null
+ goal += sizeof(uint8_t); // type
+ goal += sizeof(uint16_t); // size of value
+ switch (prop->mType) {
+ case MediaAnalyticsItem::kTypeInt32:
+ goal += sizeof(uint32_t);
+ break;
+ case MediaAnalyticsItem::kTypeInt64:
+ goal += sizeof(uint64_t);
+ break;
+ case MediaAnalyticsItem::kTypeDouble:
+ goal += sizeof(double);
+ break;
+ case MediaAnalyticsItem::kTypeRate:
+ goal += 2 * sizeof(uint64_t);
+ break;
+ case MediaAnalyticsItem::kTypeCString:
+ // length + actual string + null
+ goal += strlen(prop->u.CStringValue) + 1;
+ break;
+ default:
+ ALOGE("found bad Prop type: %d, idx %d, name %s",
+ prop->mType, i, prop->mName);
+ return false;
+ }
+ }
+
+ // now that we have a size... let's allocate and fill
+ build = (char *)malloc(goal);
+ if (build == NULL)
+ return false;
+
+ memset(build, 0, goal);
+
+ char *filling = build;
+
+#define _INSERT(val, size) \
+ { memcpy(filling, &(val), (size)); filling += (size);}
+#define _INSERTSTRING(val, size) \
+ { memcpy(filling, (val), (size)); filling += (size);}
+
+ _INSERT(goal, sizeof(int32_t));
+ _INSERT(version, sizeof(int32_t));
+ _INSERT(count, sizeof(int32_t));
+
+ for (int i = 0 ; i < count; i++ ) {
+ Prop *prop = &mProps[i];
+ int16_t attrNameLen = strlen(prop->mName) + 1;
+ _INSERT(attrNameLen, sizeof(int16_t));
+ _INSERTSTRING(prop->mName, attrNameLen); // termination included
+ int8_t elemtype;
+ int16_t elemsize;
+ switch (prop->mType) {
+ case MediaAnalyticsItem::kTypeInt32:
+ {
+ elemtype = kInt32;
+ _INSERT(elemtype, sizeof(int8_t));
+ elemsize = sizeof(int32_t);
+ _INSERT(elemsize, sizeof(int16_t));
+
+ _INSERT(prop->u.int32Value, sizeof(int32_t));
+ break;
+ }
+ case MediaAnalyticsItem::kTypeInt64:
+ {
+ elemtype = kInt64;
+ _INSERT(elemtype, sizeof(int8_t));
+ elemsize = sizeof(int64_t);
+ _INSERT(elemsize, sizeof(int16_t));
+
+ _INSERT(prop->u.int64Value, sizeof(int64_t));
+ break;
+ }
+ case MediaAnalyticsItem::kTypeDouble:
+ {
+ elemtype = kDouble;
+ _INSERT(elemtype, sizeof(int8_t));
+ elemsize = sizeof(double);
+ _INSERT(elemsize, sizeof(int16_t));
+
+ _INSERT(prop->u.doubleValue, sizeof(double));
+ break;
+ }
+ case MediaAnalyticsItem::kTypeRate:
+ {
+ elemtype = kRate;
+ _INSERT(elemtype, sizeof(int8_t));
+ elemsize = 2 * sizeof(uint64_t);
+ _INSERT(elemsize, sizeof(int16_t));
+
+ _INSERT(prop->u.rate.count, sizeof(uint64_t));
+ _INSERT(prop->u.rate.duration, sizeof(uint64_t));
+ break;
+ }
+ case MediaAnalyticsItem::kTypeCString:
+ {
+ elemtype = kCString;
+ _INSERT(elemtype, sizeof(int8_t));
+ elemsize = strlen(prop->u.CStringValue) + 1;
+ _INSERT(elemsize, sizeof(int16_t));
+
+ _INSERTSTRING(prop->u.CStringValue, elemsize);
+ break;
+ }
+ default:
+ // error if can't encode; warning if can't decode
+ ALOGE("found bad Prop type: %d, idx %d, name %s",
+ prop->mType, i, prop->mName);
+ goto badness;
+ }
+ }
+
+ if (build + goal != filling) {
+ ALOGE("problems populating; wrote=%d planned=%d",
+ (int)(filling-build), goal);
+ goto badness;
+ }
+
+ *pbuffer = build;
+ *plength = goal;
+
+ return true;
+
+ badness:
+ free(build);
+ return false;
+}
+
} // namespace android
diff --git a/media/libmediametrics/MediaMetrics.cpp b/media/libmediametrics/MediaMetrics.cpp
index 9b08aa7..6109190 100644
--- a/media/libmediametrics/MediaMetrics.cpp
+++ b/media/libmediametrics/MediaMetrics.cpp
@@ -34,7 +34,7 @@
// manage the overall record
mediametrics_handle_t mediametrics_create(mediametricskey_t key) {
- android::MediaAnalyticsItem *item = new android::MediaAnalyticsItem(key);
+ android::MediaAnalyticsItem *item = android::MediaAnalyticsItem::create(key);
return (mediametrics_handle_t) item;
}
@@ -187,18 +187,9 @@
return android::MediaAnalyticsItem::isEnabled();
}
-#if 0
-// do not expose this as is.
-// need to revisit (or redefine) how the android::Parcel parameter is handled
-// so that it meets the stable-API criteria for updateable components.
-//
-int32_t mediametrics_writeToParcel(mediametrics_handle_t handle, android::Parcel *parcel) {
+bool mediametrics_getAttributes(mediametrics_handle_t handle, char **buffer, size_t *length) {
android::MediaAnalyticsItem *item = (android::MediaAnalyticsItem *) handle;
- if (item == NULL) {
- return -1;
- }
- return item->writeToParcel(parcel);
+ if (item == NULL) return false;
+ return item->dumpAttributes(buffer, length);
+
}
-#endif
-
-
diff --git a/media/libmediametrics/include/MediaAnalyticsItem.h b/media/libmediametrics/include/MediaAnalyticsItem.h
index b99cd91..2f9e7c2 100644
--- a/media/libmediametrics/include/MediaAnalyticsItem.h
+++ b/media/libmediametrics/include/MediaAnalyticsItem.h
@@ -17,9 +17,10 @@
#ifndef ANDROID_MEDIA_MEDIAANALYTICSITEM_H
#define ANDROID_MEDIA_MEDIAANALYTICSITEM_H
-#include <cutils/properties.h>
#include <string>
#include <sys/types.h>
+
+#include <cutils/properties.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/RefBase.h>
@@ -84,6 +85,10 @@
public:
+ // so clients do not need to know size details
+ static MediaAnalyticsItem* create(Key key);
+ static MediaAnalyticsItem* create();
+
// access functions for the class
MediaAnalyticsItem();
MediaAnalyticsItem(Key);
@@ -175,6 +180,9 @@
int32_t writeToParcel(Parcel *);
int32_t readFromParcel(const Parcel&);
+ // supports the stable interface
+ bool dumpAttributes(char **pbuffer, size_t *plength);
+
std::string toString();
std::string toString(int version);
const char *toCString();
@@ -183,6 +191,11 @@
// are we collecting analytics data
static bool isEnabled();
+ private:
+ // handle Parcel version 0
+ int32_t writeToParcel0(Parcel *);
+ int32_t readFromParcel0(const Parcel&);
+
protected:
// merge fields from arg into this
diff --git a/media/libmediametrics/include/MediaMetrics.h b/media/libmediametrics/include/MediaMetrics.h
index 4d2f352..a4e1ed2 100644
--- a/media/libmediametrics/include/MediaMetrics.h
+++ b/media/libmediametrics/include/MediaMetrics.h
@@ -85,13 +85,9 @@
void mediametrics_setUid(mediametrics_handle_t handle, uid_t uid);
bool mediametrics_isEnabled();
-#if 0
-// do not expose this as is.
-// need to revisit (or redefine) how the android::Parcel parameter is handled
-// so that it meets the stable-API criteria for updateable components.
-//
-int32_t mediametrics_writeToParcel(mediametrics_handle_t handle, android::Parcel *parcel);
-#endif
+// serialized copy of the attributes/values, mostly for upstream getMetrics() calls
+// caller owns the buffer allocated as part of this call.
+bool mediametrics_getAttributes(mediametrics_handle_t handle, char **buffer, size_t *length);
__END_DECLS
diff --git a/media/libmediametrics/libmediametrics.map.txt b/media/libmediametrics/libmediametrics.map.txt
new file mode 100644
index 0000000..c46281a
--- /dev/null
+++ b/media/libmediametrics/libmediametrics.map.txt
@@ -0,0 +1,29 @@
+LIBMEDIAMETRICS_1 {
+ global:
+ mediametrics_addDouble; # apex
+ mediametrics_addInt32; # apex
+ mediametrics_addInt64; # apex
+ mediametrics_addRate; # apex
+ mediametrics_count; # apex
+ mediametrics_create; # apex
+ mediametrics_delete; # apex
+ mediametrics_freeCString; # apex
+ mediametrics_getAttributes; # apex
+ mediametrics_getCString; # apex
+ mediametrics_getDouble; # apex
+ mediametrics_getInt32; # apex
+ mediametrics_getInt64; # apex
+ mediametrics_getKey; # apex
+ mediametrics_getRate; # apex
+ mediametrics_isEnabled; # apex
+ mediametrics_readable; # apex
+ mediametrics_selfRecord; # apex
+ mediametrics_setCString; # apex
+ mediametrics_setDouble; # apex
+ mediametrics_setInt32; # apex
+ mediametrics_setInt64; # apex
+ mediametrics_setRate; # apex
+ mediametrics_setUid; # apex
+ local:
+ *;
+};
diff --git a/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h b/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h
index 0c8d016..7804a62 100644
--- a/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h
+++ b/media/libmediaplayer2/include/mediaplayer2/MediaPlayer2Interface.h
@@ -214,6 +214,8 @@
virtual status_t setParameter(int key, const Parcel &request) = 0;
virtual status_t getParameter(int key, Parcel *reply) = 0;
+ virtual status_t getMetrics(char **buffer, size_t *length) = 0;
+
// Invoke a generic method on the player by using opaque parcels
// for the request and reply.
//
diff --git a/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h b/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h
index 78865c4..2993ab1 100644
--- a/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h
+++ b/media/libmediaplayer2/include/mediaplayer2/mediaplayer2.h
@@ -102,6 +102,7 @@
status_t setAudioAttributes(const jobject attributes);
jobject getAudioAttributes();
status_t getParameter(int key, Parcel* reply);
+ status_t getMetrics(char **buffer, size_t *length);
// Modular DRM
status_t prepareDrm(int64_t srcId,
diff --git a/media/libmediaplayer2/mediaplayer2.cpp b/media/libmediaplayer2/mediaplayer2.cpp
index f75380c..53f2fb1 100644
--- a/media/libmediaplayer2/mediaplayer2.cpp
+++ b/media/libmediaplayer2/mediaplayer2.cpp
@@ -21,7 +21,6 @@
#include <android/binder_ibinder.h>
#include <media/AudioSystem.h>
#include <media/DataSourceDesc.h>
-#include <media/MediaAnalyticsItem.h>
#include <media/MemoryLeakTrackUtil.h>
#include <media/NdkWrapper.h>
#include <media/stagefright/foundation/ADebug.h>
@@ -979,6 +978,22 @@
return status;
}
+// for mediametrics
+status_t MediaPlayer2::getMetrics(char **buffer, size_t *length) {
+ ALOGD("MediaPlayer2::getMetrics()");
+ Mutex::Autolock _l(mLock);
+ if (mPlayer == NULL) {
+ ALOGV("getMetrics: no active player");
+ return INVALID_OPERATION;
+ }
+
+ status_t status = mPlayer->getMetrics(buffer, length);
+ if (status != OK) {
+ ALOGD("getMetrics returns %d", status);
+ }
+ return status;
+}
+
void MediaPlayer2::notify(int64_t srcId, int msg, int ext1, int ext2, const PlayerMessage *obj) {
ALOGV("message received srcId=%lld, msg=%d, ext1=%d, ext2=%d",
(long long)srcId, msg, ext1, ext2);
diff --git a/media/libmediaplayer2/nuplayer2/Android.bp b/media/libmediaplayer2/nuplayer2/Android.bp
index 71cd50f..0f69b2e 100644
--- a/media/libmediaplayer2/nuplayer2/Android.bp
+++ b/media/libmediaplayer2/nuplayer2/Android.bp
@@ -51,6 +51,7 @@
"libui",
"libgui",
"libmedia",
+ "libmediametrics",
"libmediandk",
"libmediandk_utils",
"libpowermanager",
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Decoder.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2Decoder.cpp
index a5bd62d..9729d86 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Decoder.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Decoder.cpp
@@ -107,6 +107,8 @@
mStats->setInt64("frames-total", mNumFramesTotal);
mStats->setInt64("frames-dropped-input", mNumInputFramesDropped);
mStats->setInt64("frames-dropped-output", mNumOutputFramesDropped);
+ mStats->setFloat("frame-rate-total", mFrameRateTotal);
+
return mStats;
}
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
index 56e9471..1b661f2 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.cpp
@@ -92,6 +92,7 @@
static const char *kPlayerHeight = "android.media.mediaplayer.height";
static const char *kPlayerFrames = "android.media.mediaplayer.frames";
static const char *kPlayerFramesDropped = "android.media.mediaplayer.dropped";
+static const char *kPlayerFrameRate = "android.media.mediaplayer.fps";
static const char *kPlayerAMime = "android.media.mediaplayer.audio.mime";
static const char *kPlayerACodec = "android.media.mediaplayer.audio.codec";
static const char *kPlayerDuration = "android.media.mediaplayer.durationMs";
@@ -125,7 +126,7 @@
mMediaClock(new MediaClock),
mPlayer(new NuPlayer2(pid, uid, mMediaClock, context)),
mPlayerFlags(0),
- mAnalyticsItem(NULL),
+ mMetricsHandle(0),
mClientUid(uid),
mAtEOS(false),
mLooping(false),
@@ -136,9 +137,9 @@
mMediaClock->init();
- // set up an analytics record
- mAnalyticsItem = new MediaAnalyticsItem(kKeyPlayer);
- mAnalyticsItem->setUid(mClientUid);
+ // set up media metrics record
+ mMetricsHandle = mediametrics_create(kKeyPlayer);
+ mediametrics_setUid(mMetricsHandle, mClientUid);
mNuPlayer2Looper->start(
false, /* runOnCallingThread */
@@ -159,10 +160,7 @@
updateMetrics("destructor");
logMetrics("destructor");
- if (mAnalyticsItem != NULL) {
- delete mAnalyticsItem;
- mAnalyticsItem = NULL;
- }
+ mediametrics_delete(mMetricsHandle);
}
status_t NuPlayer2Driver::initCheck() {
@@ -453,15 +451,15 @@
if (mime.startsWith("video/")) {
int32_t width, height;
- mAnalyticsItem->setCString(kPlayerVMime, mime.c_str());
+ mediametrics_setCString(mMetricsHandle, kPlayerVMime, mime.c_str());
if (!name.empty()) {
- mAnalyticsItem->setCString(kPlayerVCodec, name.c_str());
+ mediametrics_setCString(mMetricsHandle, kPlayerVCodec, name.c_str());
}
if (stats->findInt32("width", &width)
&& stats->findInt32("height", &height)) {
- mAnalyticsItem->setInt32(kPlayerWidth, width);
- mAnalyticsItem->setInt32(kPlayerHeight, height);
+ mediametrics_setInt32(mMetricsHandle, kPlayerWidth, width);
+ mediametrics_setInt32(mMetricsHandle, kPlayerHeight, height);
}
int64_t numFramesTotal = 0;
@@ -469,14 +467,18 @@
stats->findInt64("frames-total", &numFramesTotal);
stats->findInt64("frames-dropped-output", &numFramesDropped);
- mAnalyticsItem->setInt64(kPlayerFrames, numFramesTotal);
- mAnalyticsItem->setInt64(kPlayerFramesDropped, numFramesDropped);
+ mediametrics_setInt64(mMetricsHandle, kPlayerFrames, numFramesTotal);
+ mediametrics_setInt64(mMetricsHandle, kPlayerFramesDropped, numFramesDropped);
+ float frameRate = 0;
+ if (stats->findFloat("frame-rate-output", &frameRate)) {
+ mediametrics_setInt64(mMetricsHandle, kPlayerFrameRate, frameRate);
+ }
} else if (mime.startsWith("audio/")) {
- mAnalyticsItem->setCString(kPlayerAMime, mime.c_str());
+ mediametrics_setCString(mMetricsHandle, kPlayerAMime, mime.c_str());
if (!name.empty()) {
- mAnalyticsItem->setCString(kPlayerACodec, name.c_str());
+ mediametrics_setCString(mMetricsHandle, kPlayerACodec, name.c_str());
}
}
}
@@ -487,17 +489,17 @@
// getDuration() uses mLock for mutex -- careful where we use it.
int64_t duration_ms = -1;
getDuration(&duration_ms);
- mAnalyticsItem->setInt64(kPlayerDuration, duration_ms);
+ mediametrics_setInt64(mMetricsHandle, kPlayerDuration, duration_ms);
- mAnalyticsItem->setInt64(kPlayerPlaying, (mPlayingTimeUs+500)/1000 );
+ mediametrics_setInt64(mMetricsHandle, kPlayerPlaying, (mPlayingTimeUs+500)/1000 );
if (mRebufferingEvents != 0) {
- mAnalyticsItem->setInt64(kPlayerRebuffering, (mRebufferingTimeUs+500)/1000 );
- mAnalyticsItem->setInt32(kPlayerRebufferingCount, mRebufferingEvents);
- mAnalyticsItem->setInt32(kPlayerRebufferingAtExit, mRebufferingAtExit);
+ mediametrics_setInt64(mMetricsHandle, kPlayerRebuffering, (mRebufferingTimeUs+500)/1000 );
+ mediametrics_setInt32(mMetricsHandle, kPlayerRebufferingCount, mRebufferingEvents);
+ mediametrics_setInt32(mMetricsHandle, kPlayerRebufferingAtExit, mRebufferingAtExit);
}
- mAnalyticsItem->setCString(kPlayerDataSourceType, mPlayer->getDataSourceType());
+ mediametrics_setCString(mMetricsHandle, kPlayerDataSourceType, mPlayer->getDataSourceType());
}
@@ -507,7 +509,7 @@
}
ALOGV("logMetrics(%p) from %s at state %d", this, where, mState);
- if (mAnalyticsItem == NULL || mAnalyticsItem->isEnabled() == false) {
+ if (mMetricsHandle == 0 || mediametrics_isEnabled() == false) {
return;
}
@@ -516,16 +518,12 @@
// and that always injects 3 fields (duration, playing time, and
// datasource) into the record.
// So the canonical "empty" record has 3 elements in it.
- if (mAnalyticsItem->count() > 3) {
-
- mAnalyticsItem->selfrecord();
-
+ if (mediametrics_count(mMetricsHandle) > 3) {
+ mediametrics_selfRecord(mMetricsHandle);
// re-init in case we prepare() and start() again.
- delete mAnalyticsItem ;
- mAnalyticsItem = new MediaAnalyticsItem(kKeyPlayer);
- if (mAnalyticsItem) {
- mAnalyticsItem->setUid(mClientUid);
- }
+ mediametrics_delete(mMetricsHandle);
+ mMetricsHandle = mediametrics_create(kKeyPlayer);
+ mediametrics_setUid(mMetricsHandle, mClientUid);
} else {
ALOGV("did not have anything to record");
}
@@ -649,19 +647,18 @@
return INVALID_OPERATION;
}
-status_t NuPlayer2Driver::getParameter(int key, Parcel *reply) {
-
- if (key == FOURCC('m','t','r','X')) {
- // mtrX -- a play on 'metrics' (not matrix)
- // gather current info all together, parcel it, and send it back
- updateMetrics("api");
- mAnalyticsItem->writeToParcel(reply);
- return OK;
- }
-
+status_t NuPlayer2Driver::getParameter(int key __unused, Parcel *reply __unused) {
return INVALID_OPERATION;
}
+status_t NuPlayer2Driver::getMetrics(char **buffer, size_t *length) {
+ updateMetrics("api");
+ if (mediametrics_getAttributes(mMetricsHandle, buffer, length))
+ return OK;
+ else
+ return FAILED_TRANSACTION;
+}
+
void NuPlayer2Driver::notifyResetComplete(int64_t /* srcId */) {
ALOGD("notifyResetComplete(%p)", this);
Mutex::Autolock autoLock(mLock);
@@ -867,11 +864,11 @@
// ext1 is our primary 'error type' value. Only add ext2 when non-zero.
// [test against msg is due to fall through from previous switch value]
if (msg == MEDIA2_ERROR) {
- mAnalyticsItem->setInt32(kPlayerError, ext1);
+ mediametrics_setInt32(mMetricsHandle, kPlayerError, ext1);
if (ext2 != 0) {
- mAnalyticsItem->setInt32(kPlayerErrorCode, ext2);
+ mediametrics_setInt32(mMetricsHandle, kPlayerErrorCode, ext2);
}
- mAnalyticsItem->setCString(kPlayerErrorState, stateString(mState).c_str());
+ mediametrics_setCString(mMetricsHandle, kPlayerErrorState, stateString(mState).c_str());
}
mAtEOS = true;
break;
diff --git a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h
index 0ec3a4b..3d299f3 100644
--- a/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h
+++ b/media/libmediaplayer2/nuplayer2/NuPlayer2Driver.h
@@ -16,7 +16,7 @@
#include <mediaplayer2/MediaPlayer2Interface.h>
-#include <media/MediaAnalyticsItem.h>
+#include <media/MediaMetrics.h>
#include <media/stagefright/foundation/ABase.h>
#include <mediaplayer2/JObjectHolder.h>
@@ -61,6 +61,7 @@
virtual void setAudioSink(const sp<AudioSink> &audioSink) override;
virtual status_t setParameter(int key, const Parcel &request) override;
virtual status_t getParameter(int key, Parcel *reply) override;
+ virtual status_t getMetrics(char **buf, size_t *length) override;
virtual status_t dump(int fd, const Vector<String16> &args) const override;
@@ -132,7 +133,7 @@
sp<AudioSink> mAudioSink;
uint32_t mPlayerFlags;
- MediaAnalyticsItem *mAnalyticsItem;
+ mediametrics_handle_t mMetricsHandle;
uid_t mClientUid;
bool mAtEOS;
diff --git a/media/libstagefright/MPEG4Writer.cpp b/media/libstagefright/MPEG4Writer.cpp
index 7df1a2d..c4015fb 100644
--- a/media/libstagefright/MPEG4Writer.cpp
+++ b/media/libstagefright/MPEG4Writer.cpp
@@ -85,7 +85,7 @@
static const int kTimestampDebugCount = 10;
static const int kItemIdBase = 10000;
static const char kExifHeader[] = {'E', 'x', 'i', 'f', '\0', '\0'};
-static const int32_t kTiffHeaderOffset = htonl(sizeof(kExifHeader));
+static const uint8_t kExifApp1Marker[] = {'E', 'x', 'i', 'f', 0xff, 0xe1};
static const uint8_t kMandatoryHevcNalUnitTypes[3] = {
kHevcNalUnitTypeVps,
@@ -125,7 +125,7 @@
bool isAudio() const { return mIsAudio; }
bool isMPEG4() const { return mIsMPEG4; }
bool usePrefix() const { return mIsAvc || mIsHevc || mIsHeic; }
- bool isExifData(const MediaBufferBase *buffer) const;
+ bool isExifData(MediaBufferBase *buffer, uint32_t *tiffHdrOffset) const;
void addChunkOffset(off64_t offset);
void addItemOffsetAndSize(off64_t offset, size_t size, bool isExif);
void flushItemRefs();
@@ -364,7 +364,7 @@
Vector<uint16_t> mProperties;
ItemRefs mDimgRefs;
- ItemRefs mCdscRefs;
+ Vector<uint16_t> mExifList;
uint16_t mImageItemId;
int32_t mIsPrimary;
int32_t mWidth, mHeight;
@@ -1368,14 +1368,16 @@
}
off64_t MPEG4Writer::addSample_l(
- MediaBuffer *buffer, bool usePrefix, bool isExif, size_t *bytesWritten) {
+ MediaBuffer *buffer, bool usePrefix,
+ uint32_t tiffHdrOffset, size_t *bytesWritten) {
off64_t old_offset = mOffset;
if (usePrefix) {
addMultipleLengthPrefixedSamples_l(buffer);
} else {
- if (isExif) {
- ::write(mFd, &kTiffHeaderOffset, 4); // exif_tiff_header_offset field
+ if (tiffHdrOffset > 0) {
+ tiffHdrOffset = htonl(tiffHdrOffset);
+ ::write(mFd, &tiffHdrOffset, 4); // exif_tiff_header_offset field
mOffset += 4;
}
@@ -1803,7 +1805,6 @@
mStartTimestampUs(-1),
mRotation(0),
mDimgRefs("dimg"),
- mCdscRefs("cdsc"),
mImageItemId(0),
mIsPrimary(0),
mWidth(0),
@@ -1984,11 +1985,34 @@
return OK;
}
-bool MPEG4Writer::Track::isExifData(const MediaBufferBase *buffer) const {
- return mIsHeic
- && (buffer->range_length() > sizeof(kExifHeader))
- && !memcmp((uint8_t *)buffer->data() + buffer->range_offset(),
- kExifHeader, sizeof(kExifHeader));
+bool MPEG4Writer::Track::isExifData(
+ MediaBufferBase *buffer, uint32_t *tiffHdrOffset) const {
+ if (!mIsHeic) {
+ return false;
+ }
+
+ // Exif block starting with 'Exif\0\0'
+ size_t length = buffer->range_length();
+ uint8_t *data = (uint8_t *)buffer->data() + buffer->range_offset();
+ if ((length > sizeof(kExifHeader))
+ && !memcmp(data, kExifHeader, sizeof(kExifHeader))) {
+ *tiffHdrOffset = sizeof(kExifHeader);
+ return true;
+ }
+
+ // Exif block starting with fourcc 'Exif' followed by APP1 marker
+ if ((length > sizeof(kExifApp1Marker) + 2 + sizeof(kExifHeader))
+ && !memcmp(data, kExifApp1Marker, sizeof(kExifApp1Marker))
+ && !memcmp(data + sizeof(kExifApp1Marker) + 2, kExifHeader, sizeof(kExifHeader))) {
+ // skip 'Exif' fourcc
+ buffer->set_range(4, buffer->range_length() - 4);
+
+ // 2-byte APP1 + 2-byte size followed by kExifHeader
+ *tiffHdrOffset = 2 + 2 + sizeof(kExifHeader);
+ return true;
+ }
+
+ return false;
}
void MPEG4Writer::Track::addChunkOffset(off64_t offset) {
@@ -2014,7 +2038,7 @@
}
if (isExif) {
- mCdscRefs.value.push_back(mOwner->addItem_l({
+ mExifList.push_back(mOwner->addItem_l({
.itemType = "Exif",
.isPrimary = false,
.isHidden = false,
@@ -2117,7 +2141,16 @@
if (mImageItemId > 0) {
mOwner->addRefs_l(mImageItemId, mDimgRefs);
- mOwner->addRefs_l(mImageItemId, mCdscRefs);
+
+ if (!mExifList.empty()) {
+ // The "cdsc" ref is from the metadata/exif item to the image item.
+ // So the refs all contain the image item.
+ ItemRefs cdscRefs("cdsc");
+ cdscRefs.value.push_back(mImageItemId);
+ for (uint16_t exifItem : mExifList) {
+ mOwner->addRefs_l(exifItem, cdscRefs);
+ }
+ }
}
}
@@ -2269,14 +2302,16 @@
while (!chunk->mSamples.empty()) {
List<MediaBuffer *>::iterator it = chunk->mSamples.begin();
- int32_t isExif;
- if (!(*it)->meta_data().findInt32(kKeyIsExif, &isExif)) {
- isExif = 0;
+ uint32_t tiffHdrOffset;
+ if (!(*it)->meta_data().findInt32(
+ kKeyExifTiffOffset, (int32_t*)&tiffHdrOffset)) {
+ tiffHdrOffset = 0;
}
+ bool isExif = (tiffHdrOffset > 0);
bool usePrefix = chunk->mTrack->usePrefix() && !isExif;
size_t bytesWritten;
- off64_t offset = addSample_l(*it, usePrefix, isExif, &bytesWritten);
+ off64_t offset = addSample_l(*it, usePrefix, tiffHdrOffset, &bytesWritten);
if (chunk->mTrack->isHeic()) {
chunk->mTrack->addItemOffsetAndSize(offset, bytesWritten, isExif);
@@ -3002,10 +3037,11 @@
}
bool isExif = false;
+ uint32_t tiffHdrOffset = 0;
int32_t isMuxerData;
if (buffer->meta_data().findInt32(kKeyIsMuxerData, &isMuxerData) && isMuxerData) {
// We only support one type of muxer data, which is Exif data block.
- isExif = isExifData(buffer);
+ isExif = isExifData(buffer, &tiffHdrOffset);
if (!isExif) {
ALOGW("Ignoring bad Exif data block");
buffer->release();
@@ -3027,7 +3063,7 @@
buffer = NULL;
if (isExif) {
- copy->meta_data().setInt32(kKeyIsExif, 1);
+ copy->meta_data().setInt32(kKeyExifTiffOffset, tiffHdrOffset);
}
bool usePrefix = this->usePrefix() && !isExif;
@@ -3300,7 +3336,8 @@
}
if (!hasMultipleTracks) {
size_t bytesWritten;
- off64_t offset = mOwner->addSample_l(copy, usePrefix, isExif, &bytesWritten);
+ off64_t offset = mOwner->addSample_l(
+ copy, usePrefix, tiffHdrOffset, &bytesWritten);
if (mIsHeic) {
addItemOffsetAndSize(offset, bytesWritten, isExif);
diff --git a/media/libstagefright/include/media/stagefright/MPEG4Writer.h b/media/libstagefright/include/media/stagefright/MPEG4Writer.h
index 1abef8c..803155d 100644
--- a/media/libstagefright/include/media/stagefright/MPEG4Writer.h
+++ b/media/libstagefright/include/media/stagefright/MPEG4Writer.h
@@ -257,7 +257,9 @@
void initInternal(int fd, bool isFirstSession);
// Acquire lock before calling these methods
- off64_t addSample_l(MediaBuffer *buffer, bool usePrefix, bool isExif, size_t *bytesWritten);
+ off64_t addSample_l(
+ MediaBuffer *buffer, bool usePrefix,
+ uint32_t tiffHdrOffset, size_t *bytesWritten);
void addLengthPrefixedSample_l(MediaBuffer *buffer);
void addMultipleLengthPrefixedSamples_l(MediaBuffer *buffer);
uint16_t addProperty_l(const ItemProperty &);
diff --git a/media/libstagefright/include/media/stagefright/MetaDataBase.h b/media/libstagefright/include/media/stagefright/MetaDataBase.h
index b99c14c..2910bd3 100644
--- a/media/libstagefright/include/media/stagefright/MetaDataBase.h
+++ b/media/libstagefright/include/media/stagefright/MetaDataBase.h
@@ -221,7 +221,8 @@
kKeyFrameCount = 'nfrm', // int32_t, total number of frame in video track
kKeyExifOffset = 'exof', // int64_t, Exif data offset
kKeyExifSize = 'exsz', // int64_t, Exif data size
- kKeyIsExif = 'exif', // bool (int32_t) buffer contains exif data block
+ kKeyExifTiffOffset = 'thdr', // int32_t, if > 0, buffer contains exif data block with
+ // tiff hdr at specified offset
kKeyPcmBigEndian = 'pcmb', // bool (int32_t)
// Key for ALAC Magic Cookie
diff --git a/services/mediacodec/seccomp_policy/mediacodec-x86.policy b/services/mediacodec/seccomp_policy/mediacodec-x86.policy
index 966e214..6d88c84 100644
--- a/services/mediacodec/seccomp_policy/mediacodec-x86.policy
+++ b/services/mediacodec/seccomp_policy/mediacodec-x86.policy
@@ -18,15 +18,19 @@
openat: 1
open: 1
getuid32: 1
+getuid: 1
+getrlimit: 1
writev: 1
ioctl: 1
close: 1
mmap2: 1
+mmap: 1
fstat64: 1
stat64: 1
statfs64: 1
madvise: 1
fstatat64: 1
+newfstatat: 1
futex: 1
munmap: 1
faccessat: 1