Merge "Ensure AAudioStreamBuilder handles null strings" into sc-dev
diff --git a/media/codec2/hidl/1.0/utils/InputSurfaceConnection.cpp b/media/codec2/hidl/1.0/utils/InputSurfaceConnection.cpp
index 5ec88ec..7c2e014 100644
--- a/media/codec2/hidl/1.0/utils/InputSurfaceConnection.cpp
+++ b/media/codec2/hidl/1.0/utils/InputSurfaceConnection.cpp
@@ -201,6 +201,8 @@
c2_status_t err = mAllocator->priorGraphicAllocation(handle, &alloc);
mAllocatorMutex.unlock();
if (err != OK) {
+ native_handle_close(handle);
+ native_handle_delete(handle);
return UNKNOWN_ERROR;
}
std::shared_ptr<C2GraphicBlock> block =
diff --git a/media/codec2/sfplugin/C2OMXNode.cpp b/media/codec2/sfplugin/C2OMXNode.cpp
index 1a92c08..466eedc 100644
--- a/media/codec2/sfplugin/C2OMXNode.cpp
+++ b/media/codec2/sfplugin/C2OMXNode.cpp
@@ -421,6 +421,8 @@
if (err != OK) {
(void)fd0.release();
(void)fd1.release();
+ native_handle_close(handle);
+ native_handle_delete(handle);
return UNKNOWN_ERROR;
}
block = _C2BlockFactory::CreateGraphicBlock(alloc);
diff --git a/media/codec2/sfplugin/Codec2Buffer.cpp b/media/codec2/sfplugin/Codec2Buffer.cpp
index fc4ee51..34e6a88 100644
--- a/media/codec2/sfplugin/Codec2Buffer.cpp
+++ b/media/codec2/sfplugin/Codec2Buffer.cpp
@@ -713,6 +713,8 @@
c2_status_t err = mAlloc->priorGraphicAllocation(handle, &alloc);
if (err != C2_OK) {
ALOGD("Failed to wrap VideoNativeMetadata into C2GraphicAllocation");
+ native_handle_close(handle);
+ native_handle_delete(handle);
return nullptr;
}
std::shared_ptr<C2GraphicBlock> block = _C2BlockFactory::CreateGraphicBlock(alloc);
diff --git a/media/codec2/vndk/include/C2AllocatorGralloc.h b/media/codec2/vndk/include/C2AllocatorGralloc.h
index 578cf76..1da3e14 100644
--- a/media/codec2/vndk/include/C2AllocatorGralloc.h
+++ b/media/codec2/vndk/include/C2AllocatorGralloc.h
@@ -37,7 +37,8 @@
* Wrap the gralloc handle and metadata into Codec2 handle recognized by
* C2AllocatorGralloc.
*
- * @return a new NON-OWNING C2Handle that must be deleted using native_handle_delete.
+ * @return a new NON-OWNING C2Handle that must be closed and deleted using native_handle_close and
+ * native_handle_delete.
*/
C2Handle *WrapNativeCodec2GrallocHandle(
const native_handle_t *const handle,
diff --git a/media/codec2/vndk/platform/C2BqBuffer.cpp b/media/codec2/vndk/platform/C2BqBuffer.cpp
index e14b4b1..3f6fa7d 100644
--- a/media/codec2/vndk/platform/C2BqBuffer.cpp
+++ b/media/codec2/vndk/platform/C2BqBuffer.cpp
@@ -364,6 +364,8 @@
std::shared_ptr<C2GraphicAllocation> alloc;
c2_status_t err = mAllocator->priorGraphicAllocation(c2Handle, &alloc);
if (err != C2_OK) {
+ native_handle_close(c2Handle);
+ native_handle_delete(c2Handle);
return err;
}
std::shared_ptr<C2BufferQueueBlockPoolData> poolData =
diff --git a/media/libeffects/preprocessing/Android.bp b/media/libeffects/preprocessing/Android.bp
index 37b2ae0..87ed8b6 100644
--- a/media/libeffects/preprocessing/Android.bp
+++ b/media/libeffects/preprocessing/Android.bp
@@ -48,4 +48,9 @@
"libhardware_headers",
"libwebrtc_absl_headers",
],
+ target: {
+ darwin: {
+ enabled: false,
+ },
+ },
}
diff --git a/media/libeffects/preprocessing/tests/Android.bp b/media/libeffects/preprocessing/tests/Android.bp
index 806bc2b..6413945 100644
--- a/media/libeffects/preprocessing/tests/Android.bp
+++ b/media/libeffects/preprocessing/tests/Android.bp
@@ -29,6 +29,11 @@
"libaudioeffects",
"libhardware_headers",
],
+ target: {
+ darwin: {
+ enabled: false,
+ },
+ },
}
cc_test {
diff --git a/media/libmediatranscoding/transcoder/MediaTranscoder.cpp b/media/libmediatranscoding/transcoder/MediaTranscoder.cpp
index 74ddce4..413f049 100644
--- a/media/libmediatranscoding/transcoder/MediaTranscoder.cpp
+++ b/media/libmediatranscoding/transcoder/MediaTranscoder.cpp
@@ -29,24 +29,37 @@
namespace android {
-static AMediaFormat* mergeMediaFormats(AMediaFormat* base, AMediaFormat* overlay) {
- if (base == nullptr || overlay == nullptr) {
+static std::shared_ptr<AMediaFormat> createVideoTrackFormat(AMediaFormat* srcFormat,
+ AMediaFormat* options) {
+ if (srcFormat == nullptr || options == nullptr) {
LOG(ERROR) << "Cannot merge null formats";
return nullptr;
}
- AMediaFormat* format = AMediaFormat_new();
- if (AMediaFormat_copy(format, base) != AMEDIA_OK) {
- AMediaFormat_delete(format);
- return nullptr;
+ // ------- Define parameters to copy from the source track format -------
+ std::vector<AMediaFormatUtils::EntryCopier> srcParamsToCopy{
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_MIME, String),
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_DURATION, Int64),
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_WIDTH, Int32),
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_HEIGHT, Int32),
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_FRAME_RATE, Int32),
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_RANGE, Int32),
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_STANDARD, Int32),
+ ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_TRANSFER, Int32),
+ };
+
+ // If the destination codec is the same as the source codec, we can preserve profile and level
+ // from the source track as default values. Otherwise leave them unspecified.
+ const char *srcMime, *dstMime;
+ AMediaFormat_getString(srcFormat, AMEDIAFORMAT_KEY_MIME, &srcMime);
+ if (!AMediaFormat_getString(options, AMEDIAFORMAT_KEY_MIME, &dstMime) ||
+ strcmp(srcMime, dstMime) == 0) {
+ srcParamsToCopy.push_back(ENTRY_COPIER(AMEDIAFORMAT_KEY_PROFILE, String));
+ srcParamsToCopy.push_back(ENTRY_COPIER(AMEDIAFORMAT_KEY_LEVEL, String));
}
- // Note: AMediaFormat does not expose a function for appending values from another format or for
- // iterating over all values and keys in a format. Instead we define a static list of known keys
- // along with their value types and copy the ones that are present. A better solution would be
- // to either implement required functions in NDK or to parse the overlay format's string
- // representation and copy all existing keys.
- static const AMediaFormatUtils::EntryCopier kSupportedFormatEntries[] = {
+ // ------- Define parameters to copy from the caller's options -------
+ static const std::vector<AMediaFormatUtils::EntryCopier> kSupportedOptions{
ENTRY_COPIER(AMEDIAFORMAT_KEY_MIME, String),
ENTRY_COPIER(AMEDIAFORMAT_KEY_DURATION, Int64),
ENTRY_COPIER(AMEDIAFORMAT_KEY_WIDTH, Int32),
@@ -54,7 +67,6 @@
ENTRY_COPIER(AMEDIAFORMAT_KEY_BIT_RATE, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_PROFILE, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_LEVEL, Int32),
- ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_FORMAT, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_RANGE, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_STANDARD, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_TRANSFER, Int32),
@@ -63,10 +75,12 @@
ENTRY_COPIER(AMEDIAFORMAT_KEY_PRIORITY, Int32),
ENTRY_COPIER2(AMEDIAFORMAT_KEY_OPERATING_RATE, Float, Int32),
};
- const size_t entryCount = sizeof(kSupportedFormatEntries) / sizeof(kSupportedFormatEntries[0]);
- AMediaFormatUtils::CopyFormatEntries(overlay, format, kSupportedFormatEntries, entryCount);
- return format;
+ // ------- Copy parameters from source and options to the destination -------
+ auto trackFormat = std::shared_ptr<AMediaFormat>(AMediaFormat_new(), &AMediaFormat_delete);
+ AMediaFormatUtils::CopyFormatEntries(srcFormat, trackFormat.get(), srcParamsToCopy);
+ AMediaFormatUtils::CopyFormatEntries(options, trackFormat.get(), kSupportedOptions);
+ return trackFormat;
}
void MediaTranscoder::onThreadFinished(const void* thread, media_status_t threadStatus,
@@ -270,7 +284,8 @@
return trackFormats;
}
-media_status_t MediaTranscoder::configureTrackFormat(size_t trackIndex, AMediaFormat* trackFormat) {
+media_status_t MediaTranscoder::configureTrackFormat(size_t trackIndex,
+ AMediaFormat* destinationOptions) {
if (mSampleReader == nullptr) {
LOG(ERROR) << "Source must be configured before tracks";
return AMEDIA_ERROR_INVALID_OPERATION;
@@ -281,14 +296,15 @@
}
std::shared_ptr<MediaTrackTranscoder> transcoder;
- std::shared_ptr<AMediaFormat> format;
+ std::shared_ptr<AMediaFormat> trackFormat;
- if (trackFormat == nullptr) {
+ if (destinationOptions == nullptr) {
transcoder = std::make_shared<PassthroughTrackTranscoder>(shared_from_this());
} else {
+ AMediaFormat* srcTrackFormat = mSourceTrackFormats[trackIndex].get();
+
const char* srcMime = nullptr;
- if (!AMediaFormat_getString(mSourceTrackFormats[trackIndex].get(), AMEDIAFORMAT_KEY_MIME,
- &srcMime)) {
+ if (!AMediaFormat_getString(srcTrackFormat, AMEDIAFORMAT_KEY_MIME, &srcMime)) {
LOG(ERROR) << "Source track #" << trackIndex << " has no mime type";
return AMEDIA_ERROR_MALFORMED;
}
@@ -301,7 +317,7 @@
}
const char* dstMime = nullptr;
- if (AMediaFormat_getString(trackFormat, AMEDIAFORMAT_KEY_MIME, &dstMime)) {
+ if (AMediaFormat_getString(destinationOptions, AMEDIAFORMAT_KEY_MIME, &dstMime)) {
if (strncmp(dstMime, "video/", 6) != 0) {
LOG(ERROR) << "Unable to convert media types for track #" << trackIndex << ", from "
<< srcMime << " to " << dstMime;
@@ -311,14 +327,11 @@
transcoder = VideoTrackTranscoder::create(shared_from_this(), mPid, mUid);
- AMediaFormat* mergedFormat =
- mergeMediaFormats(mSourceTrackFormats[trackIndex].get(), trackFormat);
- if (mergedFormat == nullptr) {
- LOG(ERROR) << "Unable to merge source and destination formats";
+ trackFormat = createVideoTrackFormat(srcTrackFormat, destinationOptions);
+ if (trackFormat == nullptr) {
+ LOG(ERROR) << "Unable to create video track format";
return AMEDIA_ERROR_UNKNOWN;
}
-
- format = std::shared_ptr<AMediaFormat>(mergedFormat, &AMediaFormat_delete);
}
media_status_t status = mSampleReader->selectTrack(trackIndex);
@@ -327,7 +340,7 @@
return status;
}
- status = transcoder->configure(mSampleReader, trackIndex, format);
+ status = transcoder->configure(mSampleReader, trackIndex, trackFormat);
if (status != AMEDIA_OK) {
LOG(ERROR) << "Configure track transcoder for track #" << trackIndex << " returned error "
<< status;
diff --git a/media/libmediatranscoding/transcoder/NdkCommon.cpp b/media/libmediatranscoding/transcoder/NdkCommon.cpp
index fb909b2..2d85df7 100644
--- a/media/libmediatranscoding/transcoder/NdkCommon.cpp
+++ b/media/libmediatranscoding/transcoder/NdkCommon.cpp
@@ -60,19 +60,19 @@
DEFINE_FORMAT_VALUE_COPY_FUNC(int32_t, Int32);
DEFINE_FORMAT_VALUE_COPY_FUNC(float, Float);
-void CopyFormatEntries(AMediaFormat* from, AMediaFormat* to, const EntryCopier* entries,
- size_t entryCount) {
+void CopyFormatEntries(AMediaFormat* from, AMediaFormat* to,
+ const std::vector<EntryCopier>& entries) {
if (from == nullptr || to == nullptr) {
LOG(ERROR) << "Cannot copy null formats";
return;
- } else if (entries == nullptr || entryCount < 1) {
+ } else if (entries.empty()) {
LOG(WARNING) << "No entries to copy";
return;
}
- for (size_t i = 0; i < entryCount; ++i) {
- if (!entries[i].copy(entries[i].key, from, to) && entries[i].copy2 != nullptr) {
- entries[i].copy2(entries[i].key, from, to);
+ for (auto& entry : entries) {
+ if (!entry.copy(entry.key, from, to) && entry.copy2 != nullptr) {
+ entry.copy2(entry.key, from, to);
}
}
}
diff --git a/media/libmediatranscoding/transcoder/VideoTrackTranscoder.cpp b/media/libmediatranscoding/transcoder/VideoTrackTranscoder.cpp
index ab08d73..4405180 100644
--- a/media/libmediatranscoding/transcoder/VideoTrackTranscoder.cpp
+++ b/media/libmediatranscoding/transcoder/VideoTrackTranscoder.cpp
@@ -147,7 +147,7 @@
if (auto transcoder = wrapper->getTranscoder()) {
const bool isDecoder = codec == transcoder->mDecoder;
const char* kCodecName = (isDecoder ? "Decoder" : "Encoder");
- LOG(DEBUG) << kCodecName << " format changed: " << AMediaFormat_toString(format);
+ LOG(INFO) << kCodecName << " format changed: " << AMediaFormat_toString(format);
transcoder->mCodecMessageQueue.push([transcoder, format, isDecoder] {
transcoder->updateTrackFormat(format, isDecoder);
});
@@ -280,7 +280,7 @@
}
mEncoder = std::make_shared<CodecWrapper>(encoder, shared_from_this());
- LOG(DEBUG) << "Configuring encoder with: " << AMediaFormat_toString(mDestinationFormat.get());
+ LOG(INFO) << "Configuring encoder with: " << AMediaFormat_toString(mDestinationFormat.get());
status = AMediaCodec_configure(mEncoder->getCodec(), mDestinationFormat.get(),
NULL /* surface */, NULL /* crypto */,
AMEDIACODEC_CONFIGURE_FLAG_ENCODE);
@@ -332,15 +332,13 @@
AMediaFormat_setInt32(decoderFormat.get(), TBD_AMEDIACODEC_PARAMETER_KEY_ALLOW_FRAME_DROP, 0);
// Copy over configurations that apply to both encoder and decoder.
- static const EntryCopier kEncoderEntriesToCopy[] = {
+ static const std::vector<EntryCopier> kEncoderEntriesToCopy{
ENTRY_COPIER2(AMEDIAFORMAT_KEY_OPERATING_RATE, Float, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_PRIORITY, Int32),
};
- const size_t entryCount = sizeof(kEncoderEntriesToCopy) / sizeof(kEncoderEntriesToCopy[0]);
- CopyFormatEntries(mDestinationFormat.get(), decoderFormat.get(), kEncoderEntriesToCopy,
- entryCount);
+ CopyFormatEntries(mDestinationFormat.get(), decoderFormat.get(), kEncoderEntriesToCopy);
- LOG(DEBUG) << "Configuring decoder with: " << AMediaFormat_toString(decoderFormat.get());
+ LOG(INFO) << "Configuring decoder with: " << AMediaFormat_toString(decoderFormat.get());
status = AMediaCodec_configure(mDecoder, decoderFormat.get(), mSurface, NULL /* crypto */,
0 /* flags */);
if (status != AMEDIA_OK) {
@@ -487,9 +485,6 @@
onOutputSampleAvailable(sample);
mLastSampleWasSync = sample->info.flags & SAMPLE_FLAG_SYNC_SAMPLE;
- } else if (bufferIndex == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
- AMediaFormat* newFormat = AMediaCodec_getOutputFormat(mEncoder->getCodec());
- LOG(DEBUG) << "Encoder output format changed: " << AMediaFormat_toString(newFormat);
}
if (bufferInfo.flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM) {
@@ -509,15 +504,14 @@
void VideoTrackTranscoder::updateTrackFormat(AMediaFormat* outputFormat, bool fromDecoder) {
if (fromDecoder) {
- static const AMediaFormatUtils::EntryCopier kValuesToCopy[] = {
+ static const std::vector<AMediaFormatUtils::EntryCopier> kValuesToCopy{
ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_RANGE, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_STANDARD, Int32),
ENTRY_COPIER(AMEDIAFORMAT_KEY_COLOR_TRANSFER, Int32),
};
AMediaFormat* params = AMediaFormat_new();
if (params != nullptr) {
- AMediaFormatUtils::CopyFormatEntries(outputFormat, params, kValuesToCopy,
- std::size(kValuesToCopy));
+ AMediaFormatUtils::CopyFormatEntries(outputFormat, params, kValuesToCopy);
if (AMediaCodec_setParameters(mEncoder->getCodec(), params) != AMEDIA_OK) {
LOG(WARNING) << "Unable to update encoder with color information";
}
@@ -589,7 +583,7 @@
// TODO: transfer other fields as required.
mActualOutputFormat = std::shared_ptr<AMediaFormat>(formatCopy, &AMediaFormat_delete);
- LOG(DEBUG) << "Actual output format: " << AMediaFormat_toString(formatCopy);
+ LOG(INFO) << "Actual output format: " << AMediaFormat_toString(formatCopy);
notifyTrackFormatAvailable();
}
diff --git a/media/libmediatranscoding/transcoder/include/media/NdkCommon.h b/media/libmediatranscoding/transcoder/include/media/NdkCommon.h
index a7ed6a7..c5547c6 100644
--- a/media/libmediatranscoding/transcoder/include/media/NdkCommon.h
+++ b/media/libmediatranscoding/transcoder/include/media/NdkCommon.h
@@ -19,6 +19,8 @@
#include <media/NdkMediaFormat.h>
+#include <vector>
+
extern const char* AMEDIA_MIMETYPE_VIDEO_VP8;
extern const char* AMEDIA_MIMETYPE_VIDEO_VP9;
extern const char* AMEDIA_MIMETYPE_VIDEO_AV1;
@@ -82,8 +84,8 @@
bool CopyFormatEntryInt32(const char* key, AMediaFormat* from, AMediaFormat* to);
bool CopyFormatEntryFloat(const char* key, AMediaFormat* from, AMediaFormat* to);
-void CopyFormatEntries(AMediaFormat* from, AMediaFormat* to, const EntryCopier* entries,
- size_t entryCount);
+void CopyFormatEntries(AMediaFormat* from, AMediaFormat* to,
+ const std::vector<EntryCopier>& entries);
bool SetDefaultFormatValueFloat(const char* key, AMediaFormat* format, float value);
bool SetDefaultFormatValueInt32(const char* key, AMediaFormat* format, int32_t value);
diff --git a/media/libstagefright/FrameDecoder.cpp b/media/libstagefright/FrameDecoder.cpp
index a78e6d2..01190b5 100644
--- a/media/libstagefright/FrameDecoder.cpp
+++ b/media/libstagefright/FrameDecoder.cpp
@@ -644,6 +644,10 @@
0,
dstBpp(),
mCaptureLayer != nullptr /*allocRotated*/);
+ if (frameMem == nullptr) {
+ return NO_MEMORY;
+ }
+
mFrame = static_cast<VideoFrame*>(frameMem->unsecurePointer());
setFrame(frameMem);
@@ -886,6 +890,11 @@
if (mFrame == NULL) {
sp<IMemory> frameMem = allocVideoFrame(
trackMeta(), mWidth, mHeight, mTileWidth, mTileHeight, dstBpp());
+
+ if (frameMem == nullptr) {
+ return NO_MEMORY;
+ }
+
mFrame = static_cast<VideoFrame*>(frameMem->unsecurePointer());
setFrame(frameMem);
diff --git a/media/libstagefright/MediaExtractorFactory.cpp b/media/libstagefright/MediaExtractorFactory.cpp
index 7c981b3..d77845f 100644
--- a/media/libstagefright/MediaExtractorFactory.cpp
+++ b/media/libstagefright/MediaExtractorFactory.cpp
@@ -188,11 +188,11 @@
// sanity check check struct version, uuid, name
if (plugin->def.def_version != EXTRACTORDEF_VERSION_NDK_V1 &&
plugin->def.def_version != EXTRACTORDEF_VERSION_NDK_V2) {
- ALOGE("don't understand extractor format %u, ignoring.", plugin->def.def_version);
+ ALOGW("don't understand extractor format %u, ignoring.", plugin->def.def_version);
return;
}
if (memcmp(&plugin->def.extractor_uuid, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16) == 0) {
- ALOGE("invalid UUID, ignoring");
+ ALOGW("invalid UUID, ignoring");
return;
}
if (plugin->def.extractor_name == NULL || strlen(plugin->def.extractor_name) == 0) {
@@ -244,13 +244,17 @@
void *libHandle = android_dlopen_ext(
libPath.string(),
RTLD_NOW | RTLD_LOCAL, dlextinfo);
- CHECK(libHandle != nullptr)
- << "couldn't dlopen(" << libPath.string() << ") " << strerror(errno);
+ if (libHandle == nullptr) {
+ ALOGI("dlopen(%s) reported error %s", libPath.string(), strerror(errno));
+ continue;
+ }
GetExtractorDef getDef =
(GetExtractorDef) dlsym(libHandle, "GETEXTRACTORDEF");
- CHECK(getDef != nullptr)
- << libPath.string() << " does not contain sniffer";
+ if (getDef == nullptr) {
+ ALOGI("no sniffer found in %s", libPath.string());
+ continue;
+ }
ALOGV("registering sniffer for %s", libPath.string());
RegisterExtractor(
@@ -258,7 +262,7 @@
}
closedir(libDir);
} else {
- ALOGE("couldn't opendir(%s)", libDirPath);
+ ALOGI("plugin directory not present (%s)", libDirPath);
}
}
diff --git a/media/libstagefright/Utils.cpp b/media/libstagefright/Utils.cpp
index f63740e..51d9730 100644
--- a/media/libstagefright/Utils.cpp
+++ b/media/libstagefright/Utils.cpp
@@ -1675,7 +1675,7 @@
if (msg->findString("mime", &mime)) {
meta->setCString(kKeyMIMEType, mime.c_str());
} else {
- ALOGE("did not find mime type");
+ ALOGI("did not find mime type");
return BAD_VALUE;
}
@@ -1725,7 +1725,7 @@
meta->setInt32(kKeyWidth, width);
meta->setInt32(kKeyHeight, height);
} else {
- ALOGE("did not find width and/or height");
+ ALOGI("did not find width and/or height");
return BAD_VALUE;
}
@@ -1814,7 +1814,7 @@
int32_t numChannels, sampleRate;
if (!msg->findInt32("channel-count", &numChannels) ||
!msg->findInt32("sample-rate", &sampleRate)) {
- ALOGE("did not find channel-count and/or sample-rate");
+ ALOGI("did not find channel-count and/or sample-rate");
return BAD_VALUE;
}
meta->setInt32(kKeyChannelCount, numChannels);
diff --git a/media/libstagefright/foundation/AMessage.cpp b/media/libstagefright/foundation/AMessage.cpp
index f242b19..6bb7b37 100644
--- a/media/libstagefright/foundation/AMessage.cpp
+++ b/media/libstagefright/foundation/AMessage.cpp
@@ -1078,6 +1078,17 @@
return OK;
}
+status_t AMessage::removeEntryByName(const char *name) {
+ if (name == nullptr) {
+ return BAD_VALUE;
+ }
+ size_t index = findEntryByName(name);
+ if (index >= mNumItems) {
+ return BAD_INDEX;
+ }
+ return removeEntryAt(index);
+}
+
void AMessage::setItem(const char *name, const ItemData &item) {
if (item.used()) {
Item *it = allocateItem(name);
diff --git a/media/libstagefright/foundation/include/media/stagefright/foundation/AMessage.h b/media/libstagefright/foundation/include/media/stagefright/foundation/AMessage.h
index 31e58ba..98d6147 100644
--- a/media/libstagefright/foundation/include/media/stagefright/foundation/AMessage.h
+++ b/media/libstagefright/foundation/include/media/stagefright/foundation/AMessage.h
@@ -261,6 +261,17 @@
*/
status_t removeEntryAt(size_t index);
+ /**
+ * Removes an entry based on name.
+ *
+ * \param name name of the entry
+ *
+ * \retval OK the entry was removed successfully
+ * \retval BAD_VALUE name is invalid (null)
+ * \retval BAD_INDEX name not found
+ */
+ status_t removeEntryByName(const char *name);
+
protected:
virtual ~AMessage();
diff --git a/media/libstagefright/foundation/tests/AMessage_test.cpp b/media/libstagefright/foundation/tests/AMessage_test.cpp
new file mode 100644
index 0000000..2b11326
--- /dev/null
+++ b/media/libstagefright/foundation/tests/AMessage_test.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2021 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 "AData_test"
+
+#include <gtest/gtest.h>
+#include <utils/RefBase.h>
+
+#include <media/stagefright/foundation/AMessage.h>
+
+using namespace android;
+
+class AMessageTest : public ::testing::Test {
+};
+
+
+TEST(AMessage_tests, item_manipulation) {
+ sp<AMessage> m1 = new AMessage();
+
+ m1->setInt32("value", 2);
+ m1->setInt32("bar", 3);
+
+ int32_t i32;
+ EXPECT_TRUE(m1->findInt32("value", &i32));
+ EXPECT_EQ(2, i32);
+
+ EXPECT_TRUE(m1->findInt32("bar", &i32));
+ EXPECT_EQ(3, i32);
+
+
+ m1->setInt64("big", INT64_MAX);
+ m1->setInt64("smaller", INT64_MAX - 2);
+ m1->setInt64("smallest", 257);
+
+ int64_t i64;
+ EXPECT_TRUE(m1->findInt64("big", &i64));
+ EXPECT_EQ(INT64_MAX, i64);
+
+ EXPECT_TRUE(m1->findInt64("smaller", &i64));
+ EXPECT_EQ(INT64_MAX - 2, i64);
+
+ m1->setSize("size1", 257);
+ m1->setSize("size2", 1023);
+
+ size_t sizing;
+ EXPECT_TRUE(m1->findSize("size2", &sizing));
+ EXPECT_EQ(1023, sizing);
+ EXPECT_TRUE(m1->findSize("size1", &sizing));
+ EXPECT_EQ(257, sizing);
+
+ m1->setDouble("precise", 10.5);
+ m1->setDouble("small", 0.125);
+
+ double d;
+ EXPECT_TRUE(m1->findDouble("precise", &d));
+ EXPECT_EQ(10.5, d);
+
+ EXPECT_TRUE(m1->findDouble("small", &d));
+ EXPECT_EQ(0.125, d);
+
+ // should be unchanged from the top of the test
+ EXPECT_TRUE(m1->findInt32("bar", &i32));
+ EXPECT_EQ(3, i32);
+
+ EXPECT_FALSE(m1->findInt32("nonesuch", &i32));
+ EXPECT_FALSE(m1->findInt64("nonesuch2", &i64));
+ // types disagree, not found
+ EXPECT_FALSE(m1->findInt32("big", &i32));
+ EXPECT_FALSE(m1->findInt32("precise", &i32));
+
+ // integral types should come back true
+ EXPECT_TRUE(m1->findAsInt64("big", &i64));
+ EXPECT_EQ(INT64_MAX, i64);
+ EXPECT_TRUE(m1->findAsInt64("bar", &i64));
+ EXPECT_EQ(3, i64);
+ EXPECT_FALSE(m1->findAsInt64("precise", &i64));
+
+ // recovers ints, size, and floating point values
+ float value;
+ EXPECT_TRUE(m1->findAsFloat("value", &value));
+ EXPECT_EQ(2, value);
+ EXPECT_TRUE(m1->findAsFloat("smallest", &value));
+ EXPECT_EQ(257, value);
+ EXPECT_TRUE(m1->findAsFloat("size2", &value));
+ EXPECT_EQ(1023, value);
+ EXPECT_TRUE(m1->findAsFloat("precise", &value));
+ EXPECT_EQ(10.5, value);
+ EXPECT_TRUE(m1->findAsFloat("small", &value));
+ EXPECT_EQ(0.125, value);
+
+
+ // need to handle still:
+ // strings
+ // Object
+ // Buffer
+ // Message (nested)
+ //
+
+ // removal
+ m1->setInt32("shortlived", 2);
+ m1->setInt32("alittlelonger", 2);
+ EXPECT_EQ(OK, m1->removeEntryByName("shortlived"));
+ EXPECT_EQ(BAD_VALUE, m1->removeEntryByName(nullptr));
+ EXPECT_EQ(BAD_INDEX, m1->removeEntryByName("themythicalnonesuch"));
+ EXPECT_FALSE(m1->findInt32("shortlived", &i32));
+ EXPECT_TRUE(m1->findInt32("alittlelonger", &i32));
+
+ EXPECT_NE(OK, m1->removeEntryByName("notpresent"));
+
+}
+
diff --git a/media/libstagefright/foundation/tests/Android.bp b/media/libstagefright/foundation/tests/Android.bp
index 715b57a..e50742e 100644
--- a/media/libstagefright/foundation/tests/Android.bp
+++ b/media/libstagefright/foundation/tests/Android.bp
@@ -30,6 +30,7 @@
srcs: [
"AData_test.cpp",
+ "AMessage_test.cpp",
"Base64_test.cpp",
"Flagged_test.cpp",
"TypeTraits_test.cpp",
diff --git a/media/ndk/TEST_MAPPING b/media/ndk/TEST_MAPPING
index 1a81538..e420812 100644
--- a/media/ndk/TEST_MAPPING
+++ b/media/ndk/TEST_MAPPING
@@ -1,6 +1,7 @@
// mappings for frameworks/av/media/ndk
{
"presubmit": [
- { "name": "AImageReaderWindowHandleTest" }
+ { "name": "AImageReaderWindowHandleTest" },
+ { "name": "libmediandk_test" }
]
}
diff --git a/media/ndk/tests/Android.bp b/media/ndk/tests/Android.bp
new file mode 100644
index 0000000..984b3ee
--- /dev/null
+++ b/media/ndk/tests/Android.bp
@@ -0,0 +1,41 @@
+// Copyright (C) 2016 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.
+
+// Headers module is in frameworks/av/Android.bp because modules are not allowed
+// to refer to headers in parent directories and the headers live in
+// frameworks/av/include.
+
+package {
+ default_applicable_licenses: ["frameworks_av_media_ndk_license"],
+}
+
+cc_test {
+ name: "libmediandk_test",
+ test_suites: ["device-tests"],
+
+ cflags: [
+ "-Werror",
+ "-Wall",
+ ],
+
+ shared_libs: [
+ "liblog",
+ "libmediandk",
+ "libutils",
+ ],
+
+ srcs: [
+ "NdkMediaFormat_test.cpp",
+ ],
+}
diff --git a/media/ndk/tests/NdkMediaFormat_test.cpp b/media/ndk/tests/NdkMediaFormat_test.cpp
new file mode 100644
index 0000000..668d0a4
--- /dev/null
+++ b/media/ndk/tests/NdkMediaFormat_test.cpp
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2021 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 "NdkMediaFormat_test"
+
+#include <gtest/gtest.h>
+#include <utils/RefBase.h>
+
+#include <media/NdkMediaFormat.h>
+
+namespace android {
+
+class NdkMediaFormatTest : public ::testing::Test {
+};
+
+
+TEST(NdkMediaFormat_tests, test_create) {
+
+ AMediaFormat *fmt1 = AMediaFormat_new();
+ AMediaFormat *fmt2 = AMediaFormat_new();
+
+ EXPECT_NE(fmt1, fmt2);
+ EXPECT_NE(fmt1, nullptr);
+ EXPECT_NE(fmt2, nullptr);
+
+ AMediaFormat_delete(fmt1);
+ AMediaFormat_delete(fmt2);
+}
+
+TEST(NdkMediaFormat_tests, test_int32) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+ int32_t i32;
+ int64_t i64;
+ AMediaFormat_setInt32(fmt1, "five", 5);
+
+ EXPECT_TRUE(AMediaFormat_getInt32(fmt1, "five", &i32));
+ EXPECT_FALSE(AMediaFormat_getInt64(fmt1, "five", &i64));
+ EXPECT_EQ(i32, 5);
+
+ AMediaFormat_delete(fmt1);
+}
+
+TEST(NdkMediaFormat_tests, test_int64) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+ int64_t i64;
+ AMediaFormat_setInt64(fmt1, "verylarge", INT64_MAX);
+
+ EXPECT_TRUE(AMediaFormat_getInt64(fmt1, "verylarge", &i64));
+ EXPECT_EQ(i64, INT64_MAX);
+
+ // return unchanged if not found
+ i64 = -1;
+ EXPECT_FALSE(AMediaFormat_getInt64(fmt1, "five", &i64));
+ EXPECT_EQ(i64, -1);
+
+ AMediaFormat_delete(fmt1);
+}
+
+TEST(NdkMediaFormat_tests, test_size) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+
+ size_t size = -15;
+ AMediaFormat_setSize(fmt1, "small", 1);
+ AMediaFormat_setSize(fmt1, "medium", 10);
+ AMediaFormat_setSize(fmt1, "large", 100);
+ EXPECT_TRUE(AMediaFormat_getSize(fmt1, "medium", &size));
+ EXPECT_EQ(size, 10);
+
+ AMediaFormat_delete(fmt1);
+}
+
+TEST(NdkMediaFormat_tests, test_float) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+ float f;
+ AMediaFormat_setFloat(fmt1, "boat", 1.5);
+ AMediaFormat_setFloat(fmt1, "ship", 0.5);
+ EXPECT_TRUE(AMediaFormat_getFloat(fmt1, "boat", &f));
+ EXPECT_EQ(f, 1.5);
+ AMediaFormat_delete(fmt1);
+}
+
+TEST(NdkMediaFormat_tests, test_double) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+ double d;
+ AMediaFormat_setDouble(fmt1, "trouble", 100.5);
+ AMediaFormat_setDouble(fmt1, "dip", 0.5);
+ EXPECT_TRUE(AMediaFormat_getDouble(fmt1, "trouble", &d));
+ EXPECT_EQ(d, 100.5);
+ AMediaFormat_delete(fmt1);
+}
+
+TEST(NdkMediaFormat_tests, test_string) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+
+ const char *content = "This is my test string";
+ const char *out = nullptr;
+ AMediaFormat_setString(fmt1, "stringtheory", content);
+ EXPECT_TRUE(AMediaFormat_getString(fmt1, "stringtheory", &out));
+ EXPECT_NE(out, nullptr);
+ EXPECT_EQ(strcmp(out,content), 0);
+
+ AMediaFormat_delete(fmt1);
+}
+
+
+TEST(NdkMediaFormat_tests, test_clear) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+
+ int32_t i32;
+ AMediaFormat_setInt32(fmt1, "five", 5);
+ size_t size = -15;
+ AMediaFormat_setSize(fmt1, "medium", 10);
+ float f;
+ AMediaFormat_setFloat(fmt1, "boat", 1.5);
+
+ AMediaFormat_clear(fmt1);
+ EXPECT_FALSE(AMediaFormat_getInt32(fmt1, "five", &i32));
+ EXPECT_FALSE(AMediaFormat_getSize(fmt1, "medium", &size));
+ EXPECT_FALSE(AMediaFormat_getFloat(fmt1, "boat", &f));
+
+ AMediaFormat_delete(fmt1);
+}
+
+TEST(NdkMediaFormat_tests, test_copy) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+ AMediaFormat *fmt2 = AMediaFormat_new();
+
+ double d;
+ int32_t i32;
+
+ // test copy functionality (NB: we cleared everything just above here)
+ AMediaFormat_setDouble(fmt1, "trouble", 100.5);
+ EXPECT_TRUE(AMediaFormat_getDouble(fmt1, "trouble", &d));
+ EXPECT_FALSE(AMediaFormat_getDouble(fmt2, "trouble", &d));
+
+ EXPECT_EQ(AMEDIA_OK, AMediaFormat_copy(fmt2, fmt1));
+
+ EXPECT_TRUE(AMediaFormat_getDouble(fmt2, "trouble", &d));
+ EXPECT_EQ(d, 100.5);
+
+ AMediaFormat *fmt3 = nullptr;
+ EXPECT_NE(AMEDIA_OK, AMediaFormat_copy(fmt3, fmt1));
+ EXPECT_NE(AMEDIA_OK, AMediaFormat_copy(fmt1, fmt3));
+
+ // we should lose an entry when we copy over it
+ AMediaFormat_setInt32(fmt2, "vanishing", 50);
+ EXPECT_FALSE(AMediaFormat_getInt32(fmt1, "vanishing", &i32));
+ EXPECT_TRUE(AMediaFormat_getInt32(fmt2, "vanishing", &i32));
+ EXPECT_EQ(AMEDIA_OK, AMediaFormat_copy(fmt2, fmt1));
+ EXPECT_FALSE(AMediaFormat_getInt32(fmt2, "vanishing", &i32));
+
+ AMediaFormat_delete(fmt1);
+ AMediaFormat_delete(fmt2);
+}
+
+TEST(NdkMediaFormat_tests, test_buffer) {
+ AMediaFormat *fmt1 = AMediaFormat_new();
+
+ typedef struct blockomem {
+ int leading;
+ int filled[100];
+ int trailing;
+ } block_t;
+ block_t buf = {};
+ buf.leading = 1;
+ buf.trailing = 2;
+ void *data;
+ size_t bsize;
+
+ AMediaFormat_setBuffer(fmt1, "mybuffer", &buf, sizeof(buf));
+ EXPECT_TRUE(AMediaFormat_getBuffer(fmt1, "mybuffer", &data, &bsize));
+ EXPECT_NE(&buf, data);
+ EXPECT_EQ(sizeof(buf), bsize);
+ block_t *bufp = (block_t*) data;
+ EXPECT_EQ(bufp->leading, buf.leading);
+ EXPECT_EQ(bufp->trailing, buf.trailing);
+ EXPECT_EQ(0, memcmp(&buf, data, bsize));
+
+ AMediaFormat_delete(fmt1);
+}
+
+} // namespace android
diff --git a/services/mediametrics/Android.bp b/services/mediametrics/Android.bp
index f7d1f6a..443d339 100644
--- a/services/mediametrics/Android.bp
+++ b/services/mediametrics/Android.bp
@@ -165,10 +165,18 @@
"libmediautils",
"libmemunreachable",
"libprotobuf-cpp-lite",
+ "libstagefright_foundation",
"libstatslog",
+ "libstatspull",
+ "libstatssocket",
"libutils",
],
+ export_shared_lib_headers: [
+ "libstatspull",
+ "libstatssocket",
+ ],
+
static_libs: [
"libplatformprotos",
],
diff --git a/services/mediametrics/MediaMetricsService.cpp b/services/mediametrics/MediaMetricsService.cpp
index 1a0f6a4..bfc722e 100644
--- a/services/mediametrics/MediaMetricsService.cpp
+++ b/services/mediametrics/MediaMetricsService.cpp
@@ -19,6 +19,7 @@
#include <utils/Log.h>
#include "MediaMetricsService.h"
+#include "iface_statsd.h"
#include <pwd.h> //getpwuid
@@ -30,6 +31,9 @@
#include <mediautils/MemoryLeakTrackUtil.h>
#include <memunreachable/memunreachable.h>
#include <private/android_filesystem_config.h> // UID
+#include <statslog.h>
+
+#include <set>
namespace android {
@@ -200,7 +204,6 @@
(void)mAudioAnalytics.submit(sitem, isTrusted);
- extern bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item);
(void)dump2Statsd(sitem); // failure should be logged in function.
saveItem(sitem);
return NO_ERROR;
@@ -440,6 +443,10 @@
std::lock_guard _l(mLock);
// we assume the items are roughly in time order.
mItems.emplace_back(item);
+ if (isPullable(item->getKey())) {
+ registerStatsdCallbacksIfNeeded();
+ mPullableItems[item->getKey()].emplace_back(item);
+ }
++mItemsFinalized;
if (expirations(item)
&& (!mExpireFuture.valid()
@@ -486,4 +493,57 @@
return false;
}
+void MediaMetricsService::registerStatsdCallbacksIfNeeded()
+{
+ if (mStatsdRegistered.test_and_set()) {
+ return;
+ }
+ auto tag = android::util::MEDIA_DRM_ACTIVITY_INFO;
+ auto cb = MediaMetricsService::pullAtomCallback;
+ AStatsManager_setPullAtomCallback(tag, /* metadata */ nullptr, cb, this);
+}
+
+/* static */
+bool MediaMetricsService::isPullable(const std::string &key)
+{
+ static const std::set<std::string> pullableKeys{
+ "mediadrm",
+ };
+ return pullableKeys.count(key);
+}
+
+/* static */
+std::string MediaMetricsService::atomTagToKey(int32_t atomTag)
+{
+ switch (atomTag) {
+ case android::util::MEDIA_DRM_ACTIVITY_INFO:
+ return "mediadrm";
+ }
+ return {};
+}
+
+/* static */
+AStatsManager_PullAtomCallbackReturn MediaMetricsService::pullAtomCallback(
+ int32_t atomTag, AStatsEventList* data, void* cookie)
+{
+ MediaMetricsService* svc = reinterpret_cast<MediaMetricsService*>(cookie);
+ return svc->pullItems(atomTag, data);
+}
+
+AStatsManager_PullAtomCallbackReturn MediaMetricsService::pullItems(
+ int32_t atomTag, AStatsEventList* data)
+{
+ const std::string key(atomTagToKey(atomTag));
+ if (key.empty()) {
+ return AStatsManager_PULL_SKIP;
+ }
+ std::lock_guard _l(mLock);
+ for (auto &item : mPullableItems[key]) {
+ if (const auto sitem = item.lock()) {
+ dump2Statsd(sitem, data);
+ }
+ }
+ mPullableItems[key].clear();
+ return AStatsManager_PULL_SUCCESS;
+}
} // namespace android
diff --git a/services/mediametrics/MediaMetricsService.h b/services/mediametrics/MediaMetricsService.h
index bcae397..8bc8019 100644
--- a/services/mediametrics/MediaMetricsService.h
+++ b/services/mediametrics/MediaMetricsService.h
@@ -26,6 +26,7 @@
#include <android-base/thread_annotations.h>
#include <android/media/BnMediaMetricsService.h>
#include <mediautils/ServiceUtilities.h>
+#include <stats_pull_atom_callback.h>
#include <utils/String8.h>
#include "AudioAnalytics.h"
@@ -102,6 +103,15 @@
void dumpQueue(String8 &result, int64_t sinceNs, const char* prefix) REQUIRES(mLock);
void dumpHeaders(String8 &result, int64_t sinceNs, const char* prefix) REQUIRES(mLock);
+ // support statsd pushed atoms
+ static bool isPullable(const std::string &key);
+ static std::string atomTagToKey(int32_t atomTag);
+ static AStatsManager_PullAtomCallbackReturn pullAtomCallback(
+ int32_t atomTag, AStatsEventList* data, void* cookie);
+ AStatsManager_PullAtomCallbackReturn pullItems(int32_t atomTag, AStatsEventList* data);
+ void registerStatsdCallbacksIfNeeded();
+ std::atomic_flag mStatsdRegistered = ATOMIC_FLAG_INIT;
+
// The following variables accessed without mLock
// limit how many records we'll retain
@@ -130,6 +140,12 @@
// TODO: Make separate class, use segmented queue, write lock only end.
// Note: Another analytics module might have ownership of an item longer than the log.
std::deque<std::shared_ptr<const mediametrics::Item>> mItems GUARDED_BY(mLock);
+
+ // Queues per item key, pending to be pulled by statsd.
+ // Use weak_ptr such that a pullable item can still expire.
+ using ItemKey = std::string;
+ using WeakItemQueue = std::deque<std::weak_ptr<const mediametrics::Item>>;
+ std::unordered_map<ItemKey, WeakItemQueue> mPullableItems GUARDED_BY(mLock);
};
} // namespace android
diff --git a/services/mediametrics/fuzzer/Android.bp b/services/mediametrics/fuzzer/Android.bp
index d75ded2..b03e518 100644
--- a/services/mediametrics/fuzzer/Android.bp
+++ b/services/mediametrics/fuzzer/Android.bp
@@ -50,7 +50,10 @@
"libmemunreachable",
"libprotobuf-cpp-lite",
"libstagefright",
+ "libstagefright_foundation",
"libstatslog",
+ "libstatspull",
+ "libstatssocket",
"libutils",
"mediametricsservice-aidl-cpp",
],
diff --git a/services/mediametrics/iface_statsd.cpp b/services/mediametrics/iface_statsd.cpp
index 16204de..b7c5296 100644
--- a/services/mediametrics/iface_statsd.cpp
+++ b/services/mediametrics/iface_statsd.cpp
@@ -27,7 +27,10 @@
#include <pthread.h>
#include <unistd.h>
+#include <map>
#include <memory>
+#include <string>
+#include <vector>
#include <string.h>
#include <pwd.h>
@@ -47,31 +50,13 @@
bool enabled_statsd = true;
-struct statsd_hooks {
- const char *key;
- bool (*handler)(const mediametrics::Item *);
-};
+using statsd_pusher = bool (*)(const mediametrics::Item *);
+using statsd_puller = bool (*)(const mediametrics::Item *, AStatsEventList *);
-// keep this sorted, so we can do binary searches
-static constexpr struct statsd_hooks statsd_handlers[] =
-{
- { "audiopolicy", statsd_audiopolicy },
- { "audiorecord", statsd_audiorecord },
- { "audiothread", statsd_audiothread },
- { "audiotrack", statsd_audiotrack },
- { "codec", statsd_codec},
- { "drm.vendor.Google.WidevineCDM", statsd_widevineCDM },
- { "drmmanager", statsd_drmmanager },
- { "extractor", statsd_extractor },
- { "mediadrm", statsd_mediadrm },
- { "mediaparser", statsd_mediaparser },
- { "nuplayer", statsd_nuplayer },
- { "nuplayer2", statsd_nuplayer },
- { "recorder", statsd_recorder },
-};
-
-// give me a record, i'll look at the type and upload appropriately
-bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item) {
+namespace {
+template<typename Handler, typename... Args>
+bool dump2StatsdInternal(const std::map<std::string, Handler>& handlers,
+ const std::shared_ptr<const mediametrics::Item>& item, Args... args) {
if (item == nullptr) return false;
// get the key
@@ -82,12 +67,39 @@
return false;
}
- for (const auto &statsd_handler : statsd_handlers) {
- if (key == statsd_handler.key) {
- return statsd_handler.handler(item.get());
- }
+ if (handlers.count(key)) {
+ return (handlers.at(key))(item.get(), args...);
}
return false;
}
+} // namespace
+
+// give me a record, I'll look at the type and upload appropriately
+bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item) {
+ static const std::map<std::string, statsd_pusher> statsd_pushers =
+ {
+ { "audiopolicy", statsd_audiopolicy },
+ { "audiorecord", statsd_audiorecord },
+ { "audiothread", statsd_audiothread },
+ { "audiotrack", statsd_audiotrack },
+ { "codec", statsd_codec},
+ { "drmmanager", statsd_drmmanager },
+ { "extractor", statsd_extractor },
+ { "mediadrm", statsd_mediadrm },
+ { "mediaparser", statsd_mediaparser },
+ { "nuplayer", statsd_nuplayer },
+ { "nuplayer2", statsd_nuplayer },
+ { "recorder", statsd_recorder },
+ };
+ return dump2StatsdInternal(statsd_pushers, item);
+}
+
+bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item, AStatsEventList* out) {
+ static const std::map<std::string, statsd_puller> statsd_pullers =
+ {
+ { "mediadrm", statsd_mediadrm_puller },
+ };
+ return dump2StatsdInternal(statsd_pullers, item, out);
+}
} // namespace android
diff --git a/services/mediametrics/iface_statsd.h b/services/mediametrics/iface_statsd.h
index 9b49556..1b6c79a 100644
--- a/services/mediametrics/iface_statsd.h
+++ b/services/mediametrics/iface_statsd.h
@@ -14,7 +14,13 @@
* limitations under the License.
*/
+#include <memory>
+#include <stats_event.h>
+
namespace android {
+namespace mediametrics {
+class Item;
+}
extern bool enabled_statsd;
@@ -30,7 +36,12 @@
extern bool statsd_recorder(const mediametrics::Item *);
extern bool statsd_mediadrm(const mediametrics::Item *);
-extern bool statsd_widevineCDM(const mediametrics::Item *);
extern bool statsd_drmmanager(const mediametrics::Item *);
+// component specific pullers
+extern bool statsd_mediadrm_puller(const mediametrics::Item *, AStatsEventList *);
+
+bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item);
+bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item, AStatsEventList* out);
+
} // namespace android
diff --git a/services/mediametrics/statsd_drm.cpp b/services/mediametrics/statsd_drm.cpp
index ac58929..071c549 100644
--- a/services/mediametrics/statsd_drm.cpp
+++ b/services/mediametrics/statsd_drm.cpp
@@ -17,6 +17,7 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "statsd_drm"
#include <utils/Log.h>
+#include <media/stagefright/foundation/base64.h>
#include <stdint.h>
#include <inttypes.h>
@@ -37,6 +38,7 @@
#include <array>
#include <string>
+#include <vector>
namespace android {
@@ -54,12 +56,12 @@
(void) item->getString("vendor", &vendor);
std::string description;
(void) item->getString("description", &description);
- std::string serialized_metrics;
- (void) item->getString("serialized_metrics", &serialized_metrics);
if (enabled_statsd) {
- android::util::BytesField bf_serialized(serialized_metrics.c_str(),
- serialized_metrics.size());
+ // This field is left here for backward compatibility.
+ // This field is not used anymore.
+ const std::string kUnusedField("unused");
+ android::util::BytesField bf_serialized(kUnusedField.c_str(), kUnusedField.size());
android::util::stats_write(android::util::MEDIAMETRICS_MEDIADRM_REPORTED,
timestamp, pkgName.c_str(), pkgVersionCode,
mediaApexVersion,
@@ -67,34 +69,7 @@
description.c_str(),
bf_serialized);
} else {
- ALOGV("NOT sending: mediadrm private data (len=%zu)", serialized_metrics.size());
- }
-
- return true;
-}
-
-// widevineCDM
-bool statsd_widevineCDM(const mediametrics::Item *item)
-{
- if (item == nullptr) return false;
-
- const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
- std::string pkgName = item->getPkgName();
- int64_t pkgVersionCode = item->getPkgVersionCode();
- int64_t mediaApexVersion = 0;
-
- std::string serialized_metrics;
- (void) item->getString("serialized_metrics", &serialized_metrics);
-
- if (enabled_statsd) {
- android::util::BytesField bf_serialized(serialized_metrics.c_str(),
- serialized_metrics.size());
- android::util::stats_write(android::util::MEDIAMETRICS_DRM_WIDEVINE_REPORTED,
- timestamp, pkgName.c_str(), pkgVersionCode,
- mediaApexVersion,
- bf_serialized);
- } else {
- ALOGV("NOT sending: widevine private data (len=%zu)", serialized_metrics.size());
+ ALOGV("NOT sending: mediadrm data(%s, %s)", vendor.c_str(), description.c_str());
}
return true;
@@ -145,4 +120,65 @@
return true;
}
+namespace {
+std::vector<uint8_t> base64DecodeNoPad(std::string& str) {
+ if (str.empty()) {
+ return {};
+ }
+
+ switch (str.length() % 4) {
+ case 3: str += "="; break;
+ case 2: str += "=="; break;
+ case 1: str += "==="; break;
+ case 0: /* unchanged */ break;
+ }
+
+ std::vector<uint8_t> buf(str.length() / 4 * 3, 0);
+ size_t size = buf.size();
+ if (decodeBase64(buf.data(), &size, str.c_str()) && size <= buf.size()) {
+ buf.erase(buf.begin() + size, buf.end());
+ return buf;
+ }
+ return {};
+}
+} // namespace
+
+// |out| and its contents are memory-managed by statsd.
+bool statsd_mediadrm_puller(const mediametrics::Item* item, AStatsEventList* out)
+{
+ if (item == nullptr) {
+ return false;
+ }
+
+ if (!enabled_statsd) {
+ ALOGV("NOT pulling: mediadrm activity");
+ return true;
+ }
+
+ std::string serialized_metrics;
+ (void) item->getString("serialized_metrics", &serialized_metrics);
+ const auto framework_raw(base64DecodeNoPad(serialized_metrics));
+
+ std::string plugin_metrics;
+ (void) item->getString("plugin_metrics", &plugin_metrics);
+ const auto plugin_raw(base64DecodeNoPad(plugin_metrics));
+
+ std::string vendor;
+ (void) item->getString("vendor", &vendor);
+ std::string description;
+ (void) item->getString("description", &description);
+
+ // Memory for |event| is internally managed by statsd.
+ AStatsEvent* event = AStatsEventList_addStatsEvent(out);
+ AStatsEvent_setAtomId(event, android::util::MEDIA_DRM_ACTIVITY_INFO);
+ AStatsEvent_writeString(event, item->getPkgName().c_str());
+ AStatsEvent_writeInt64(event, item->getPkgVersionCode());
+ AStatsEvent_writeString(event, vendor.c_str());
+ AStatsEvent_writeString(event, description.c_str());
+ AStatsEvent_writeByteArray(event, framework_raw.data(), framework_raw.size());
+ AStatsEvent_writeByteArray(event, plugin_raw.data(), plugin_raw.size());
+ AStatsEvent_build(event);
+ return true;
+}
+
} // namespace android
diff --git a/services/oboeservice/AAudioService.cpp b/services/oboeservice/AAudioService.cpp
index 8baf8dc..0b69bf6 100644
--- a/services/oboeservice/AAudioService.cpp
+++ b/services/oboeservice/AAudioService.cpp
@@ -39,7 +39,7 @@
using namespace aaudio;
#define MAX_STREAMS_PER_PROCESS 8
-#define AIDL_RETURN(x) *_aidl_return = (x); return Status::ok();
+#define AIDL_RETURN(x) { *_aidl_return = (x); return Status::ok(); }
#define VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(x) \
({ auto _tmp = (x); \
@@ -116,12 +116,11 @@
// Enforce limit on client processes.
Identity callingIdentity = request.getIdentity();
+ pid_t pid = IPCThreadState::self()->getCallingPid();
callingIdentity.pid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
- legacy2aidl_pid_t_int32_t(IPCThreadState::self()->getCallingPid()));
+ legacy2aidl_pid_t_int32_t(pid));
callingIdentity.uid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
legacy2aidl_uid_t_int32_t(IPCThreadState::self()->getCallingUid()));
- pid_t pid = VALUE_OR_RETURN_ILLEGAL_ARG_STATUS(
- aidl2legacy_int32_t_pid_t(callingIdentity.pid));
if (callingIdentity.pid != mAudioClient.identity.pid) {
int32_t count = AAudioClientTracker::getInstance().getStreamCount(pid);
if (count >= MAX_STREAMS_PER_PROCESS) {