Merge changes I4dd906fe,I2ef7f266 into rvc-dev
* changes:
MediaCodec: set release surface in more states
CCodec: fix resource releases
diff --git a/media/bufferpool/2.0/Android.bp b/media/bufferpool/2.0/Android.bp
index 557b7ef..536f75e 100644
--- a/media/bufferpool/2.0/Android.bp
+++ b/media/bufferpool/2.0/Android.bp
@@ -30,6 +30,7 @@
name: "libstagefright_bufferpool@2.0.1",
defaults: ["libstagefright_bufferpool@2.0-default"],
vendor_available: true,
+ min_sdk_version: "29",
// TODO: b/147147992
double_loadable: true,
cflags: [
diff --git a/media/codec2/core/Android.bp b/media/codec2/core/Android.bp
index 1f9d7ab..ce1c9ac 100644
--- a/media/codec2/core/Android.bp
+++ b/media/codec2/core/Android.bp
@@ -1,12 +1,14 @@
cc_library_headers {
name: "libcodec2_headers",
vendor_available: true,
+ min_sdk_version: "29",
export_include_dirs: ["include"],
}
cc_library_shared {
name: "libcodec2",
vendor_available: true,
+ min_sdk_version: "29",
vndk: {
enabled: true,
},
diff --git a/media/codec2/hidl/1.0/utils/Android.bp b/media/codec2/hidl/1.0/utils/Android.bp
index 75c9424..3b73350 100644
--- a/media/codec2/hidl/1.0/utils/Android.bp
+++ b/media/codec2/hidl/1.0/utils/Android.bp
@@ -48,6 +48,7 @@
cc_library {
name: "libcodec2_hidl@1.0",
vendor_available: true,
+ min_sdk_version: "29",
defaults: ["hidl_defaults"],
diff --git a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp
index 264abba..ed2016f 100644
--- a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp
@@ -22,7 +22,6 @@
#include <hidl/GtestPrinter.h>
#include <stdio.h>
#include <algorithm>
-#include <fstream>
#include <C2AllocatorIon.h>
#include <C2Buffer.h>
@@ -35,12 +34,6 @@
#include "media_c2_hidl_test_common.h"
-struct FrameInfo {
- int bytesCount;
- uint32_t flags;
- int64_t timestamp;
-};
-
static std::vector<std::tuple<std::string, std::string, std::string, std::string>>
kDecodeTestParameters;
@@ -105,6 +98,7 @@
mEos = false;
mFramesReceived = 0;
mTimestampUs = 0u;
+ mWorkResult = C2_OK;
mTimestampDevTest = false;
if (mCompName == unknown_comp) mDisableTest = true;
if (mDisableTest) std::cout << "[ WARN ] Test Disabled \n";
@@ -121,6 +115,8 @@
// Get the test parameters from GetParam call.
virtual void getParams() {}
+ virtual void validateTimestampList(int32_t* bitStreamInfo);
+
struct outputMetaData {
uint64_t timestampUs;
uint32_t rangeLength;
@@ -131,6 +127,7 @@
if (!work->worklets.empty()) {
// For decoder components current timestamp always exceeds
// previous timestamp
+ mWorkResult |= work->result;
bool codecConfig = ((work->worklets.front()->output.flags &
C2FrameData::FLAG_CODEC_CONFIG) != 0);
if (!codecConfig && !work->worklets.front()->output.buffers.empty()) {
@@ -182,6 +179,8 @@
bool mDisableTest;
bool mTimestampDevTest;
standardComp mCompName;
+
+ int32_t mWorkResult;
uint64_t mTimestampUs;
uint32_t mFramesReceived;
std::list<uint64_t> mFlushedIndices;
@@ -457,6 +456,31 @@
}
}
+void Codec2AudioDecHidlTestBase::validateTimestampList(int32_t* bitStreamInfo) {
+ uint32_t samplesReceived = 0;
+ // Update SampleRate and ChannelCount
+ ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
+ int32_t nSampleRate = bitStreamInfo[0];
+ int32_t nChannels = bitStreamInfo[1];
+ std::list<uint64_t>::iterator itIn = mTimestampUslist.begin();
+ auto itOut = oBufferMetaData.begin();
+ EXPECT_EQ(*itIn, itOut->timestampUs);
+ uint64_t expectedTimeStamp = *itIn;
+ while (itOut != oBufferMetaData.end()) {
+ EXPECT_EQ(expectedTimeStamp, itOut->timestampUs);
+ if (expectedTimeStamp != itOut->timestampUs) break;
+ // buffer samples = ((total bytes) / (ac * (bits per sample / 8))
+ samplesReceived += ((itOut->rangeLength) / (nChannels * 2));
+ expectedTimeStamp = samplesReceived * 1000000ll / nSampleRate;
+ itOut++;
+ }
+ itIn = mTimestampUslist.end();
+ --itIn;
+ EXPECT_GT(expectedTimeStamp, *itIn);
+ oBufferMetaData.clear();
+ mTimestampUslist.clear();
+}
+
TEST_P(Codec2AudioDecHidlTest, validateCompName) {
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
ALOGV("Checks if the given component is a valid audio component");
@@ -493,7 +517,7 @@
bool signalEOS = !std::get<3>(GetParam()).compare("true");
mTimestampDevTest = true;
char mURL[512], info[512];
- std::ifstream eleStream, eleInfo;
+ android::Vector<FrameInfo> Info;
strcpy(mURL, sResourceDir.c_str());
strcpy(info, sResourceDir.c_str());
@@ -503,21 +527,9 @@
return;
}
- eleInfo.open(info);
- ASSERT_EQ(eleInfo.is_open(), true);
- android::Vector<FrameInfo> Info;
- int bytesCount = 0;
- uint32_t flags = 0;
- uint32_t timestamp = 0;
- while (1) {
- if (!(eleInfo >> bytesCount)) break;
- eleInfo >> flags;
- eleInfo >> timestamp;
- bool codecConfig = ((1 << (flags - 1)) & C2FrameData::FLAG_CODEC_CONFIG) != 0;
- if (mTimestampDevTest && !codecConfig) mTimestampUslist.push_back(timestamp);
- Info.push_back({bytesCount, flags, timestamp});
- }
- eleInfo.close();
+ int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
+ ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;
+
// Reset total no of frames received
mFramesReceived = 0;
mTimestampUs = 0;
@@ -534,6 +546,7 @@
}
ASSERT_EQ(mComponent->start(), C2_OK);
ALOGV("mURL : %s", mURL);
+ std::ifstream eleStream;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
@@ -550,7 +563,7 @@
}
// blocking call to ensures application to Wait till all the inputs are
// consumed
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
eleStream.close();
if (mFramesReceived != infoSize) {
ALOGE("Input buffer count and Output buffer count mismatch");
@@ -558,32 +571,12 @@
ASSERT_TRUE(false);
}
ASSERT_EQ(mEos, true);
+
if (mTimestampDevTest) {
- uint64_t expTs;
- uint32_t samplesReceived = 0;
- // Update SampleRate and ChannelCount
- ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
- int nSampleRate = bitStreamInfo[0];
- int nChannels = bitStreamInfo[1];
- std::list<uint64_t>::iterator itIn = mTimestampUslist.begin();
- auto itOut = oBufferMetaData.begin();
- EXPECT_EQ(*itIn, itOut->timestampUs);
- expTs = *itIn;
- while (itOut != oBufferMetaData.end()) {
- EXPECT_EQ(expTs, itOut->timestampUs);
- if (expTs != itOut->timestampUs) break;
- // buffer samples = ((total bytes) / (ac * (bits per sample / 8))
- samplesReceived += ((itOut->rangeLength) / (nChannels * 2));
- expTs = samplesReceived * 1000000ll / nSampleRate;
- itOut++;
- }
- itIn = mTimestampUslist.end();
- --itIn;
- EXPECT_GT(expTs, *itIn);
- oBufferMetaData.clear();
- mTimestampUslist.clear();
+ validateTimestampList(bitStreamInfo);
}
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
// thumbnail test
@@ -592,25 +585,15 @@
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
char mURL[512], info[512];
- std::ifstream eleStream, eleInfo;
+ android::Vector<FrameInfo> Info;
strcpy(mURL, sResourceDir.c_str());
strcpy(info, sResourceDir.c_str());
GetURLForComponent(mCompName, mURL, info);
- eleInfo.open(info);
- ASSERT_EQ(eleInfo.is_open(), true);
- android::Vector<FrameInfo> Info;
- int bytesCount = 0;
- uint32_t flags = 0;
- uint32_t timestamp = 0;
- while (1) {
- if (!(eleInfo >> bytesCount)) break;
- eleInfo >> flags;
- eleInfo >> timestamp;
- Info.push_back({bytesCount, flags, timestamp});
- }
- eleInfo.close();
+ int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
+ ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;
+
int32_t bitStreamInfo[2] = {0};
if (mCompName == raw) {
bitStreamInfo[0] = 8000;
@@ -628,22 +611,25 @@
// request EOS for thumbnail
// signal EOS flag with last frame
size_t i = -1;
+ uint32_t flags;
do {
i++;
flags = 0;
if (Info[i].flags) flags = 1u << (Info[i].flags - 1);
} while (!(flags & SYNC_FRAME));
+ std::ifstream eleStream;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
mFlushedIndices, mLinearPool, eleStream, &Info, 0,
i + 1));
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
eleStream.close();
EXPECT_GE(mFramesReceived, 1U);
ASSERT_EQ(mEos, true);
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
TEST_P(Codec2AudioDecHidlTest, EOSTest) {
@@ -684,33 +670,22 @@
ASSERT_EQ(mEos, true);
ASSERT_EQ(mWorkQueue.size(), (size_t)MAX_INPUT_BUFFERS);
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
TEST_P(Codec2AudioDecHidlTest, FlushTest) {
description("Tests Flush calls");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- typedef std::unique_lock<std::mutex> ULock;
char mURL[512], info[512];
- std::ifstream eleStream, eleInfo;
+ android::Vector<FrameInfo> Info;
strcpy(mURL, sResourceDir.c_str());
strcpy(info, sResourceDir.c_str());
GetURLForComponent(mCompName, mURL, info);
- eleInfo.open(info);
- ASSERT_EQ(eleInfo.is_open(), true);
- android::Vector<FrameInfo> Info;
- int bytesCount = 0;
- uint32_t flags = 0;
- uint32_t timestamp = 0;
- mFlushedIndices.clear();
- while (1) {
- if (!(eleInfo >> bytesCount)) break;
- eleInfo >> flags;
- eleInfo >> timestamp;
- Info.push_back({bytesCount, flags, timestamp});
- }
- eleInfo.close();
+ int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
+ ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;
+
int32_t bitStreamInfo[2] = {0};
if (mCompName == raw) {
bitStreamInfo[0] = 8000;
@@ -723,44 +698,37 @@
return;
}
ASSERT_EQ(mComponent->start(), C2_OK);
- ALOGV("mURL : %s", mURL);
- eleStream.open(mURL, std::ifstream::binary);
- ASSERT_EQ(eleStream.is_open(), true);
- // Decode 128 frames and flush. here 128 is chosen to ensure there is a key
- // frame after this so that the below section can be covered for all
- // components
- uint32_t numFramesFlushed = 128;
- ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
- mFlushedIndices, mLinearPool, eleStream, &Info, 0,
- numFramesFlushed, false));
// flush
std::list<std::unique_ptr<C2Work>> flushedWork;
c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
- uint64_t frameIndex;
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- frameIndex = work->input.ordinal.frameIndex.peeku();
- std::list<uint64_t>::iterator frameIndexIt =
- std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
+
+ ALOGV("mURL : %s", mURL);
+ std::ifstream eleStream;
+ eleStream.open(mURL, std::ifstream::binary);
+ ASSERT_EQ(eleStream.is_open(), true);
+ // Decode 30 frames and flush.
+ uint32_t numFramesFlushed = FLUSH_INTERVAL;
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
+ mFlushedIndices, mLinearPool, eleStream, &Info, 0,
+ numFramesFlushed, false));
+ // flush
+ err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
+ ASSERT_EQ(err, C2_OK);
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
+
// Seek to next key frame and start decoding till the end
mFlushedIndices.clear();
int index = numFramesFlushed;
bool keyFrame = false;
- flags = 0;
+ uint32_t flags = 0;
while (index < (int)Info.size()) {
if (Info[index].flags) flags = 1u << (Info[index].flags - 1);
if ((flags & SYNC_FRAME) == SYNC_FRAME) {
@@ -779,25 +747,13 @@
eleStream.close();
err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- frameIndex = work->input.ordinal.frameIndex.peeku();
- std::list<uint64_t>::iterator frameIndexIt =
- std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
- ASSERT_EQ(mFlushedIndices.empty(), true);
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
+ // TODO: (b/154671521)
+ // Add assert for mWorkResult
ASSERT_EQ(mComponent->stop(), C2_OK);
}
@@ -862,7 +818,7 @@
// consumed
if (!mEos) {
ALOGV("Waiting for input consumption");
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
}
eleStream.close();
@@ -909,4 +865,4 @@
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
-}
\ No newline at end of file
+}
diff --git a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp
index 5f3ae41..63f39de 100644
--- a/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp
@@ -95,6 +95,7 @@
mEos = false;
mCsd = false;
mFramesReceived = 0;
+ mWorkResult = C2_OK;
if (mCompName == unknown_comp) mDisableTest = true;
if (mDisableTest) std::cout << "[ WARN ] Test Disabled \n";
getInputMaxBufSize();
@@ -115,6 +116,7 @@
void handleWorkDone(std::list<std::unique_ptr<C2Work>>& workItems) {
for (std::unique_ptr<C2Work>& work : workItems) {
if (!work->worklets.empty()) {
+ mWorkResult |= work->result;
workDone(mComponent, work, mFlushedIndices, mQueueLock, mQueueCondition, mWorkQueue,
mEos, mCsd, mFramesReceived);
}
@@ -135,6 +137,8 @@
bool mCsd;
bool mDisableTest;
standardComp mCompName;
+
+ int32_t mWorkResult;
uint32_t mFramesReceived;
int32_t mInputMaxBufSize;
std::list<uint64_t> mFlushedIndices;
@@ -236,6 +240,41 @@
return false;
}
+// Get config params for a component
+bool getConfigParams(Codec2AudioEncHidlTest::standardComp compName, int32_t* nChannels,
+ int32_t* nSampleRate, int32_t* samplesPerFrame) {
+ switch (compName) {
+ case Codec2AudioEncHidlTest::aac:
+ *nChannels = 2;
+ *nSampleRate = 48000;
+ *samplesPerFrame = 1024;
+ break;
+ case Codec2AudioEncHidlTest::flac:
+ *nChannels = 2;
+ *nSampleRate = 48000;
+ *samplesPerFrame = 1152;
+ break;
+ case Codec2AudioEncHidlTest::opus:
+ *nChannels = 2;
+ *nSampleRate = 48000;
+ *samplesPerFrame = 960;
+ break;
+ case Codec2AudioEncHidlTest::amrnb:
+ *nChannels = 1;
+ *nSampleRate = 8000;
+ *samplesPerFrame = 160;
+ break;
+ case Codec2AudioEncHidlTest::amrwb:
+ *nChannels = 1;
+ *nSampleRate = 16000;
+ *samplesPerFrame = 160;
+ break;
+ default:
+ return false;
+ }
+ return true;
+}
+
// LookUpTable of clips and metadata for component testing
void GetURLForComponent(Codec2AudioEncHidlTest::standardComp comp, char* mURL) {
struct CompToURL {
@@ -367,36 +406,18 @@
bool signalEOS = !std::get<2>(GetParam()).compare("true");
// Ratio w.r.t to mInputMaxBufSize
int32_t inputMaxBufRatio = std::stoi(std::get<3>(GetParam()));
- ;
- // Setting default sampleRate
- int32_t nChannels = 2;
- int32_t nSampleRate = 44100;
- switch (mCompName) {
- case aac:
- nChannels = 2;
- nSampleRate = 48000;
- break;
- case flac:
- nChannels = 2;
- nSampleRate = 48000;
- break;
- case opus:
- nChannels = 2;
- nSampleRate = 48000;
- break;
- case amrnb:
- nChannels = 1;
- nSampleRate = 8000;
- break;
- case amrwb:
- nChannels = 1;
- nSampleRate = 16000;
- break;
- default:
- ASSERT_TRUE(false);
+ int32_t nChannels;
+ int32_t nSampleRate;
+ int32_t samplesPerFrame;
+
+ if (!getConfigParams(mCompName, &nChannels, &nSampleRate, &samplesPerFrame)) {
+ std::cout << "Failed to get the config params for " << mCompName << " component\n";
+ std::cout << "[ WARN ] Test Skipped \n";
+ return;
}
- int32_t samplesPerFrame = ((mInputMaxBufSize / inputMaxBufRatio) / (nChannels * 2));
+
+ samplesPerFrame = ((mInputMaxBufSize / inputMaxBufRatio) / (nChannels * 2));
ALOGV("signalEOS %d mInputMaxBufSize %d samplesPerFrame %d", signalEOS, mInputMaxBufSize,
samplesPerFrame);
@@ -416,7 +437,7 @@
// If EOS is not sent, sending empty input with EOS flag
if (!signalEOS) {
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1);
ASSERT_NO_FATAL_FAILURE(testInputBuffer(mComponent, mQueueLock, mWorkQueue,
C2FrameData::FLAG_END_OF_STREAM, false));
numFrames += 1;
@@ -424,7 +445,7 @@
// blocking call to ensures application to Wait till all the inputs are
// consumed
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
eleStream.close();
if (mFramesReceived != numFrames) {
ALOGE("Input buffer count and Output buffer count mismatch");
@@ -439,6 +460,7 @@
}
ASSERT_EQ(mEos, true);
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
TEST_P(Codec2AudioEncHidlTest, EOSTest) {
@@ -479,50 +501,26 @@
}
ASSERT_EQ(mEos, true);
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
TEST_P(Codec2AudioEncHidlTest, FlushTest) {
description("Test Request for flush");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- typedef std::unique_lock<std::mutex> ULock;
char mURL[512];
strcpy(mURL, sResourceDir.c_str());
GetURLForComponent(mCompName, mURL);
- // Setting default configuration
mFlushedIndices.clear();
- int32_t nChannels = 2;
- int32_t nSampleRate = 44100;
- int32_t samplesPerFrame = 1024;
- switch (mCompName) {
- case aac:
- nChannels = 2;
- nSampleRate = 48000;
- samplesPerFrame = 1024;
- break;
- case flac:
- nChannels = 2;
- nSampleRate = 48000;
- samplesPerFrame = 1152;
- break;
- case opus:
- nChannels = 2;
- nSampleRate = 48000;
- samplesPerFrame = 960;
- break;
- case amrnb:
- nChannels = 1;
- nSampleRate = 8000;
- samplesPerFrame = 160;
- break;
- case amrwb:
- nChannels = 1;
- nSampleRate = 16000;
- samplesPerFrame = 160;
- break;
- default:
- ASSERT_TRUE(false);
+ int32_t nChannels;
+ int32_t nSampleRate;
+ int32_t samplesPerFrame;
+
+ if (!getConfigParams(mCompName, &nChannels, &nSampleRate, &samplesPerFrame)) {
+ std::cout << "Failed to get the config params for " << mCompName << " component\n";
+ std::cout << "[ WARN ] Test Skipped \n";
+ return;
}
if (!setupConfigParam(mComponent, nChannels, nSampleRate)) {
@@ -536,33 +534,24 @@
uint32_t numFrames = 128;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
+ // flush
+ std::list<std::unique_ptr<C2Work>> flushedWork;
+ c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
+ ASSERT_EQ(err, C2_OK);
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
ALOGV("mURL : %s", mURL);
ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
mFlushedIndices, mLinearPool, eleStream, numFramesFlushed,
samplesPerFrame, nChannels, nSampleRate));
- std::list<std::unique_ptr<C2Work>> flushedWork;
- c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
+ err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
- uint64_t frameIndex;
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- frameIndex = work->input.ordinal.frameIndex.peeku();
- std::list<uint64_t>::iterator frameIndexIt =
- std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
- mFlushedIndices.clear();
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
mFlushedIndices, mLinearPool, eleStream,
numFrames - numFramesFlushed, samplesPerFrame, nChannels,
@@ -570,25 +559,13 @@
eleStream.close();
err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- frameIndex = work->input.ordinal.frameIndex.peeku();
- std::list<uint64_t>::iterator frameIndexIt =
- std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
- ASSERT_EQ(mFlushedIndices.empty(), true);
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
+ // TODO: (b/154671521)
+ // Add assert for mWorkResult
ASSERT_EQ(mComponent->stop(), C2_OK);
}
diff --git a/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.cpp b/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.cpp
index da8225c..a41c2dc 100644
--- a/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.cpp
@@ -160,4 +160,57 @@
}
return parameters;
-}
\ No newline at end of file
+}
+
+// Populate Info vector and return number of CSDs
+int32_t populateInfoVector(std::string info, android::Vector<FrameInfo>* frameInfo,
+ bool timestampDevTest, std::list<uint64_t>* timestampUslist) {
+ std::ifstream eleInfo;
+ eleInfo.open(info);
+ if (!eleInfo.is_open()) {
+ ALOGE("Can't open info file");
+ return -1;
+ }
+ int32_t numCsds = 0;
+ int32_t bytesCount = 0;
+ uint32_t flags = 0;
+ uint32_t timestamp = 0;
+ while (1) {
+ if (!(eleInfo >> bytesCount)) break;
+ eleInfo >> flags;
+ eleInfo >> timestamp;
+ bool codecConfig = flags ? ((1 << (flags - 1)) & C2FrameData::FLAG_CODEC_CONFIG) != 0 : 0;
+ if (codecConfig) numCsds++;
+ bool nonDisplayFrame = ((flags & FLAG_NON_DISPLAY_FRAME) != 0);
+ if (timestampDevTest && !codecConfig && !nonDisplayFrame) {
+ timestampUslist->push_back(timestamp);
+ }
+ frameInfo->push_back({bytesCount, flags, timestamp});
+ }
+ ALOGV("numCsds : %d", numCsds);
+ eleInfo.close();
+ return numCsds;
+}
+
+void verifyFlushOutput(std::list<std::unique_ptr<C2Work>>& flushedWork,
+ std::list<std::unique_ptr<C2Work>>& workQueue,
+ std::list<uint64_t>& flushedIndices, std::mutex& queueLock) {
+ // Update mFlushedIndices based on the index received from flush()
+ typedef std::unique_lock<std::mutex> ULock;
+ uint64_t frameIndex;
+ ULock l(queueLock);
+ for (std::unique_ptr<C2Work>& work : flushedWork) {
+ ASSERT_NE(work, nullptr);
+ frameIndex = work->input.ordinal.frameIndex.peeku();
+ std::list<uint64_t>::iterator frameIndexIt =
+ std::find(flushedIndices.begin(), flushedIndices.end(), frameIndex);
+ if (!flushedIndices.empty() && (frameIndexIt != flushedIndices.end())) {
+ flushedIndices.erase(frameIndexIt);
+ work->input.buffers.clear();
+ work->worklets.clear();
+ workQueue.push_back(std::move(work));
+ }
+ }
+ ASSERT_EQ(flushedIndices.empty(), true);
+ flushedWork.clear();
+}
diff --git a/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h b/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h
index 4b5e0a6..50e3ac5 100644
--- a/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h
+++ b/media/codec2/hidl/1.0/vts/functional/common/media_c2_hidl_test_common.h
@@ -25,10 +25,13 @@
#include <gtest/gtest.h>
#include <hidl/HidlSupport.h>
#include <chrono>
+#include <fstream>
+#define FLAG_NON_DISPLAY_FRAME (1 << 4)
#define MAX_RETRY 20
#define TIME_OUT 400ms
#define MAX_INPUT_BUFFERS 8
+#define FLUSH_INTERVAL 30
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
@@ -39,6 +42,12 @@
static std::vector<std::tuple<std::string, std::string>> kTestParameters;
+struct FrameInfo {
+ int bytesCount;
+ uint32_t flags;
+ int64_t timestamp;
+};
+
/*
* Handle Callback functions onWorkDone(), onTripped(),
* onError(), onDeath(), onFramesRendered()
@@ -123,4 +132,10 @@
int64_t getNowUs();
+int32_t populateInfoVector(std::string info, android::Vector<FrameInfo>* frameInfo,
+ bool timestampDevTest, std::list<uint64_t>* timestampUslist);
+
+void verifyFlushOutput(std::list<std::unique_ptr<C2Work>>& flushedWork,
+ std::list<std::unique_ptr<C2Work>>& workQueue,
+ std::list<uint64_t>& flushedIndices, std::mutex& queueLock);
#endif // MEDIA_C2_HIDL_TEST_COMMON_H
diff --git a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp
index f216429..3362336 100644
--- a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp
@@ -21,7 +21,6 @@
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <stdio.h>
-#include <fstream>
#include <C2AllocatorIon.h>
#include <C2Buffer.h>
@@ -39,12 +38,6 @@
#include "media_c2_hidl_test_common.h"
#include "media_c2_video_hidl_test_common.h"
-struct FrameInfo {
- int bytesCount;
- uint32_t flags;
- int64_t timestamp;
-};
-
static std::vector<std::tuple<std::string, std::string, std::string, std::string>>
kDecodeTestParameters;
@@ -111,6 +104,7 @@
mEos = false;
mFramesReceived = 0;
mTimestampUs = 0u;
+ mWorkResult = C2_OK;
mTimestampDevTest = false;
if (mCompName == unknown_comp) mDisableTest = true;
@@ -141,6 +135,7 @@
// For decoder components current timestamp always exceeds
// previous timestamp
typedef std::unique_lock<std::mutex> ULock;
+ mWorkResult |= work->result;
bool codecConfig = ((work->worklets.front()->output.flags &
C2FrameData::FLAG_CODEC_CONFIG) != 0);
if (!codecConfig && !work->worklets.front()->output.buffers.empty()) {
@@ -170,7 +165,7 @@
}
}
}
- bool mCsd;
+ bool mCsd = false;
workDone(mComponent, work, mFlushedIndices, mQueueLock, mQueueCondition, mWorkQueue,
mEos, mCsd, mFramesReceived);
(void)mCsd;
@@ -200,6 +195,8 @@
std::list<uint64_t> mTimestampUslist;
std::list<uint64_t> mFlushedIndices;
standardComp mCompName;
+
+ int32_t mWorkResult;
uint32_t mFramesReceived;
C2BlockPool::local_id_t mBlockPoolId;
std::shared_ptr<C2BlockPool> mLinearPool;
@@ -463,38 +460,27 @@
uint32_t streamIndex = std::stoi(std::get<2>(GetParam()));
bool signalEOS = !std::get<2>(GetParam()).compare("true");
+ mTimestampDevTest = true;
char mURL[512], info[512];
- std::ifstream eleStream, eleInfo;
+ android::Vector<FrameInfo> Info;
+
strcpy(mURL, sResourceDir.c_str());
strcpy(info, sResourceDir.c_str());
+
GetURLForComponent(mCompName, mURL, info, streamIndex);
- eleInfo.open(info);
- ASSERT_EQ(eleInfo.is_open(), true) << mURL << " - file not found";
- android::Vector<FrameInfo> Info;
- int bytesCount = 0;
- uint32_t flags = 0;
- uint32_t timestamp = 0;
- mTimestampDevTest = true;
mFlushedIndices.clear();
mTimestampUslist.clear();
- while (1) {
- if (!(eleInfo >> bytesCount)) break;
- eleInfo >> flags;
- eleInfo >> timestamp;
- bool codecConfig = flags ? ((1 << (flags - 1)) & C2FrameData::FLAG_CODEC_CONFIG) != 0 : 0;
- bool nonDisplayFrame = ((flags & FLAG_NON_DISPLAY_FRAME) != 0);
- if (mTimestampDevTest && !codecConfig && !nonDisplayFrame)
- mTimestampUslist.push_back(timestamp);
- Info.push_back({bytesCount, flags, timestamp});
- }
- eleInfo.close();
+
+ int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
+ ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;
ASSERT_EQ(mComponent->start(), C2_OK);
// Reset total no of frames received
mFramesReceived = 0;
mTimestampUs = 0;
ALOGV("mURL : %s", mURL);
+ std::ifstream eleStream;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
@@ -504,7 +490,7 @@
// If EOS is not sent, sending empty input with EOS flag
size_t infoSize = Info.size();
if (!signalEOS) {
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1);
ASSERT_NO_FATAL_FAILURE(testInputBuffer(mComponent, mQueueLock, mWorkQueue,
C2FrameData::FLAG_END_OF_STREAM, false));
infoSize += 1;
@@ -513,7 +499,7 @@
// consumed
if (!mEos) {
ALOGV("Waiting for input consumption");
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
}
eleStream.close();
@@ -525,6 +511,7 @@
if (mTimestampDevTest) EXPECT_EQ(mTimestampUslist.empty(), true);
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
// Adaptive Test
@@ -622,7 +609,7 @@
// blocking call to ensures application to Wait till all the inputs are
// consumed
ALOGV("Waiting for input consumption");
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
if (mFramesReceived != ((Info.size()) + 1)) {
ALOGE("Input buffer count and Output buffer count mismatch");
@@ -631,6 +618,7 @@
}
if (mTimestampDevTest) EXPECT_EQ(mTimestampUslist.empty(), true);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
// thumbnail test
@@ -639,26 +627,16 @@
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
char mURL[512], info[512];
- std::ifstream eleStream, eleInfo;
+ android::Vector<FrameInfo> Info;
strcpy(mURL, sResourceDir.c_str());
strcpy(info, sResourceDir.c_str());
GetURLForComponent(mCompName, mURL, info);
- eleInfo.open(info);
- ASSERT_EQ(eleInfo.is_open(), true);
- android::Vector<FrameInfo> Info;
- int bytesCount = 0;
- uint32_t flags = 0;
- uint32_t timestamp = 0;
- while (1) {
- if (!(eleInfo >> bytesCount)) break;
- eleInfo >> flags;
- eleInfo >> timestamp;
- Info.push_back({bytesCount, flags, timestamp});
- }
- eleInfo.close();
+ int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
+ ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;
+ uint32_t flags = 0;
for (size_t i = 0; i < MAX_ITERATIONS; i++) {
ASSERT_EQ(mComponent->start(), C2_OK);
@@ -671,18 +649,21 @@
if (Info[j].flags) flags = 1u << (Info[j].flags - 1);
} while (!(flags & SYNC_FRAME));
+
+ std::ifstream eleStream;
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
mFlushedIndices, mLinearPool, eleStream, &Info, 0,
j + 1));
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
eleStream.close();
EXPECT_GE(mFramesReceived, 1U);
ASSERT_EQ(mEos, true);
ASSERT_EQ(mComponent->stop(), C2_OK);
}
ASSERT_EQ(mComponent->release(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
TEST_P(Codec2VideoDecHidlTest, EOSTest) {
@@ -723,72 +704,59 @@
ASSERT_EQ(mEos, true);
ASSERT_EQ(mWorkQueue.size(), (size_t)MAX_INPUT_BUFFERS);
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mWorkResult, C2_OK);
}
TEST_P(Codec2VideoDecHidlTest, FlushTest) {
description("Tests Flush calls");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- typedef std::unique_lock<std::mutex> ULock;
+
ASSERT_EQ(mComponent->start(), C2_OK);
+
char mURL[512], info[512];
- std::ifstream eleStream, eleInfo;
+ android::Vector<FrameInfo> Info;
strcpy(mURL, sResourceDir.c_str());
strcpy(info, sResourceDir.c_str());
GetURLForComponent(mCompName, mURL, info);
- eleInfo.open(info);
- ASSERT_EQ(eleInfo.is_open(), true);
- android::Vector<FrameInfo> Info;
- int bytesCount = 0;
- uint32_t flags = 0;
- uint32_t timestamp = 0;
mFlushedIndices.clear();
- while (1) {
- if (!(eleInfo >> bytesCount)) break;
- eleInfo >> flags;
- eleInfo >> timestamp;
- Info.push_back({bytesCount, flags, timestamp});
- }
- eleInfo.close();
+
+ int32_t numCsds = populateInfoVector(info, &Info, mTimestampDevTest, &mTimestampUslist);
+ ASSERT_GE(numCsds, 0) << "Error in parsing input info file: " << info;
ALOGV("mURL : %s", mURL);
- eleStream.open(mURL, std::ifstream::binary);
- ASSERT_EQ(eleStream.is_open(), true);
- // Decode 128 frames and flush. here 128 is chosen to ensure there is a key
- // frame after this so that the below section can be covered for all
- // components
- uint32_t numFramesFlushed = 128;
- ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
- mFlushedIndices, mLinearPool, eleStream, &Info, 0,
- numFramesFlushed, false));
+
// flush
std::list<std::unique_ptr<C2Work>> flushedWork;
c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- auto frameIndexIt = std::find(mFlushedIndices.begin(), mFlushedIndices.end(),
- work->input.ordinal.frameIndex.peeku());
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
+ std::ifstream eleStream;
+ eleStream.open(mURL, std::ifstream::binary);
+ ASSERT_EQ(eleStream.is_open(), true);
+ // Decode 30 frames and flush. here 30 is chosen to ensure there is a key
+ // frame after this so that the below section can be covered for all
+ // components
+ uint32_t numFramesFlushed = FLUSH_INTERVAL;
+ ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
+ mFlushedIndices, mLinearPool, eleStream, &Info, 0,
+ numFramesFlushed, false));
+ // flush
+ err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
+ ASSERT_EQ(err, C2_OK);
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
// Seek to next key frame and start decoding till the end
- mFlushedIndices.clear();
int index = numFramesFlushed;
bool keyFrame = false;
- flags = 0;
+ uint32_t flags = 0;
while (index < (int)Info.size()) {
if (Info[index].flags) flags = 1u << (Info[index].flags - 1);
if ((flags & SYNC_FRAME) == SYNC_FRAME) {
@@ -807,25 +775,13 @@
eleStream.close();
err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- uint64_t frameIndex = work->input.ordinal.frameIndex.peeku();
- std::list<uint64_t>::iterator frameIndexIt =
- std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
- ASSERT_EQ(mFlushedIndices.empty(), true);
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
+ // TODO: (b/154671521)
+ // Add assert for mWorkResult
ASSERT_EQ(mComponent->stop(), C2_OK);
}
@@ -880,7 +836,7 @@
// consumed
if (!mEos) {
ALOGV("Waiting for input consumption");
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
}
eleStream.close();
@@ -930,4 +886,4 @@
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
-}
\ No newline at end of file
+}
diff --git a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp
index 823e11b..9e425d2 100644
--- a/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp
+++ b/media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp
@@ -492,7 +492,7 @@
// If EOS is not sent, sending empty input with EOS flag
inputFrames += ENC_NUM_FRAMES;
if (!signalEOS) {
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue, 1);
ASSERT_NO_FATAL_FAILURE(testInputBuffer(mComponent, mQueueLock, mWorkQueue,
C2FrameData::FLAG_END_OF_STREAM, false));
inputFrames += 1;
@@ -501,7 +501,7 @@
// blocking call to ensures application to Wait till all the inputs are
// consumed
ALOGD("Waiting for input consumption");
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
eleStream.close();
if (mFramesReceived != inputFrames) {
@@ -520,6 +520,9 @@
if (mTimestampDevTest) EXPECT_EQ(mTimestampUslist.empty(), true);
ASSERT_EQ(mComponent->stop(), C2_OK);
+
+ // TODO: (b/155534991)
+ // Add assert for mFailedWorkReceived
}
TEST_P(Codec2VideoEncHidlTest, EOSTest) {
@@ -560,13 +563,13 @@
}
ASSERT_EQ(mEos, true);
ASSERT_EQ(mComponent->stop(), C2_OK);
+ ASSERT_EQ(mFailedWorkReceived, 0);
}
TEST_P(Codec2VideoEncHidlTest, FlushTest) {
description("Test Request for flush");
if (mDisableTest) GTEST_SKIP() << "Test is disabled";
- typedef std::unique_lock<std::mutex> ULock;
char mURL[512];
int32_t nWidth = ENC_DEFAULT_FRAME_WIDTH;
int32_t nHeight = ENC_DEFAULT_FRAME_HEIGHT;
@@ -587,9 +590,17 @@
eleStream.open(mURL, std::ifstream::binary);
ASSERT_EQ(eleStream.is_open(), true);
ALOGV("mURL : %s", mURL);
+ // flush
+ std::list<std::unique_ptr<C2Work>> flushedWork;
+ c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
+ ASSERT_EQ(err, C2_OK);
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
+
ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
mFlushedIndices, mGraphicPool, eleStream, mDisableTest, 0,
- numFramesFlushed, nWidth, nHeight));
+ numFramesFlushed, nWidth, nHeight, false, false));
// mDisableTest will be set if buffer was not fetched properly.
// This may happen when resolution is not proper but config succeeded
// In this cases, we skip encoding the input stream
@@ -599,29 +610,14 @@
return;
}
- std::list<std::unique_ptr<C2Work>> flushedWork;
- c2_status_t err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
+ // flush
+ err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
- uint64_t frameIndex;
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- frameIndex = work->input.ordinal.frameIndex.peeku();
- std::list<uint64_t>::iterator frameIndexIt =
- std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
- mFlushedIndices.clear();
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
ASSERT_NO_FATAL_FAILURE(encodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
mFlushedIndices, mGraphicPool, eleStream, mDisableTest,
numFramesFlushed, numFrames - numFramesFlushed, nWidth,
@@ -638,25 +634,13 @@
err = mComponent->flush(C2Component::FLUSH_COMPONENT, &flushedWork);
ASSERT_EQ(err, C2_OK);
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
- (size_t)MAX_INPUT_BUFFERS - flushedWork.size()));
- {
- // Update mFlushedIndices based on the index received from flush()
- ULock l(mQueueLock);
- for (std::unique_ptr<C2Work>& work : flushedWork) {
- ASSERT_NE(work, nullptr);
- frameIndex = work->input.ordinal.frameIndex.peeku();
- std::list<uint64_t>::iterator frameIndexIt =
- std::find(mFlushedIndices.begin(), mFlushedIndices.end(), frameIndex);
- if (!mFlushedIndices.empty() && (frameIndexIt != mFlushedIndices.end())) {
- mFlushedIndices.erase(frameIndexIt);
- work->input.buffers.clear();
- work->worklets.clear();
- mWorkQueue.push_back(std::move(work));
- }
- }
- }
- ASSERT_EQ(mFlushedIndices.empty(), true);
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue,
+ (size_t)MAX_INPUT_BUFFERS - flushedWork.size());
+ ASSERT_NO_FATAL_FAILURE(
+ verifyFlushOutput(flushedWork, mWorkQueue, mFlushedIndices, mQueueLock));
+ ASSERT_EQ(mWorkQueue.size(), MAX_INPUT_BUFFERS);
+ // TODO: (b/154671521)
+ // Add assert for mFailedWorkReceived
ASSERT_EQ(mComponent->stop(), C2_OK);
}
@@ -691,7 +675,7 @@
// blocking call to ensures application to Wait till all the inputs are
// consumed
ALOGD("Waiting for input consumption");
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
if (mFramesReceived != 3) {
std::cout << "[ WARN ] Component didn't receive all buffers back \n";
@@ -746,7 +730,7 @@
}
ALOGD("Waiting for input consumption");
- ASSERT_NO_FATAL_FAILURE(waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue));
+ waitOnInputConsumption(mQueueLock, mQueueCondition, mWorkQueue);
ASSERT_EQ(mEos, true);
ASSERT_EQ(mComponent->stop(), C2_OK);
diff --git a/media/codec2/hidl/1.0/vts/functional/video/media_c2_video_hidl_test_common.h b/media/codec2/hidl/1.0/vts/functional/video/media_c2_video_hidl_test_common.h
index 9c1a5cb..d3a693b 100644
--- a/media/codec2/hidl/1.0/vts/functional/video/media_c2_video_hidl_test_common.h
+++ b/media/codec2/hidl/1.0/vts/functional/video/media_c2_video_hidl_test_common.h
@@ -22,7 +22,6 @@
#define ENC_DEFAULT_FRAME_WIDTH 352
#define ENC_DEFAULT_FRAME_HEIGHT 288
#define MAX_ITERATIONS 128
-#define FLAG_NON_DISPLAY_FRAME (1 << 4)
#define ALIGN(_sz, _align) ((_sz + (_align - 1)) & ~(_align - 1))
diff --git a/media/codec2/hidl/1.1/utils/Android.bp b/media/codec2/hidl/1.1/utils/Android.bp
index 8fddf98..386f6e2 100644
--- a/media/codec2/hidl/1.1/utils/Android.bp
+++ b/media/codec2/hidl/1.1/utils/Android.bp
@@ -52,6 +52,7 @@
cc_library {
name: "libcodec2_hidl@1.1",
vendor_available: true,
+ min_sdk_version: "29",
defaults: ["hidl_defaults"],
diff --git a/media/codec2/sfplugin/utils/Android.bp b/media/codec2/sfplugin/utils/Android.bp
index 205abdc..6287221 100644
--- a/media/codec2/sfplugin/utils/Android.bp
+++ b/media/codec2/sfplugin/utils/Android.bp
@@ -1,6 +1,7 @@
cc_library_shared {
name: "libsfplugin_ccodec_utils",
vendor_available: true,
+ min_sdk_version: "29",
double_loadable: true,
srcs: [
diff --git a/media/codec2/vndk/Android.bp b/media/codec2/vndk/Android.bp
index f3e37e0..6f7acce 100644
--- a/media/codec2/vndk/Android.bp
+++ b/media/codec2/vndk/Android.bp
@@ -7,6 +7,8 @@
// TODO: Remove this when this module is moved back to frameworks/av.
vendor_available: true,
+
+ min_sdk_version: "29",
}
// !!!DO NOT DEPEND ON THIS SHARED LIBRARY DIRECTLY!!!
@@ -14,6 +16,7 @@
cc_library_shared {
name: "libcodec2_vndk",
vendor_available: true,
+ min_sdk_version: "29",
// TODO: b/147147883
double_loadable: true,
@@ -87,6 +90,8 @@
"libcodec2_vndk",
"libutils",
],
+
+ min_sdk_version: "29",
}
// public dependency for implementing Codec 2 framework utilities
diff --git a/media/extractors/mp4/MPEG4Extractor.cpp b/media/extractors/mp4/MPEG4Extractor.cpp
index 54f1fa2..d06c8ba 100755
--- a/media/extractors/mp4/MPEG4Extractor.cpp
+++ b/media/extractors/mp4/MPEG4Extractor.cpp
@@ -20,6 +20,7 @@
#include <ctype.h>
#include <inttypes.h>
#include <algorithm>
+#include <map>
#include <memory>
#include <stdint.h>
#include <stdlib.h>
@@ -204,6 +205,7 @@
Vector<size_t> encryptedsizes;
};
Vector<Sample> mCurrentSamples;
+ std::map<off64_t, uint32_t> mDrmOffsets;
MPEG4Source(const MPEG4Source &);
MPEG4Source &operator=(const MPEG4Source &);
@@ -5153,6 +5155,9 @@
if (chunk_type == FOURCC("moof")) {
mNextMoofOffset = *offset;
break;
+ } else if (chunk_type == FOURCC("mdat")) {
+ parseChunk(offset);
+ continue;
} else if (chunk_size == 0) {
break;
}
@@ -5214,6 +5219,22 @@
// parse DRM info if present
ALOGV("MPEG4Source::parseChunk mdat");
// if saiz/saoi was previously observed, do something with the sampleinfos
+ status_t err = OK;
+ auto kv = mDrmOffsets.lower_bound(*offset);
+ if (kv != mDrmOffsets.end()) {
+ auto drmoffset = kv->first;
+ auto flags = kv->second;
+ mDrmOffsets.erase(kv);
+ ALOGV("mdat chunk_size %" PRIu64 " drmoffset %" PRId64 " offset %" PRId64,
+ chunk_size, drmoffset, *offset);
+ if (chunk_size >= drmoffset - *offset) {
+ err = parseClearEncryptedSizes(drmoffset, false, flags,
+ chunk_size - (drmoffset - *offset));
+ }
+ }
+ if (err != OK) {
+ return err;
+ }
*offset += chunk_size;
break;
}
@@ -5395,8 +5416,10 @@
off64_t drmoffset = mCurrentSampleInfoOffsets[0]; // from moof
drmoffset += mCurrentMoofOffset;
+ mDrmOffsets[drmoffset] = flags;
+ ALOGV("saio drmoffset %" PRId64 " flags %u", drmoffset, flags);
- return parseClearEncryptedSizes(drmoffset, false, 0, mCurrentMoofSize);
+ return OK;
}
status_t MPEG4Source::parseClearEncryptedSizes(
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index 0d20f20..0c40cbb 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -1,6 +1,8 @@
cc_library_headers {
name: "libaudioclient_headers",
vendor_available: true,
+ min_sdk_version: "29",
+
header_libs: [
"libaudiofoundation_headers",
],
diff --git a/media/libaudioclient/AudioRecord.cpp b/media/libaudioclient/AudioRecord.cpp
index d4c421a..7efa67c 100644
--- a/media/libaudioclient/AudioRecord.cpp
+++ b/media/libaudioclient/AudioRecord.cpp
@@ -773,7 +773,7 @@
// use case 3: obtain/release mode
(mTransfer == TRANSFER_OBTAIN);
if (!useCaseAllowed) {
- ALOGW("%s(%d): AUDIO_INPUT_FLAG_FAST denied, incompatible transfer = %s",
+ ALOGD("%s(%d): AUDIO_INPUT_FLAG_FAST denied, incompatible transfer = %s",
__func__, mPortId,
convertTransferToText(mTransfer));
mFlags = (audio_input_flags_t) (mFlags & ~(AUDIO_INPUT_FLAG_FAST |
diff --git a/media/libaudioclient/AudioTrack.cpp b/media/libaudioclient/AudioTrack.cpp
index 011b0fa..dd84511 100644
--- a/media/libaudioclient/AudioTrack.cpp
+++ b/media/libaudioclient/AudioTrack.cpp
@@ -1632,7 +1632,7 @@
mAwaitBoost = true;
}
} else {
- ALOGW("%s(%d): AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %zu -> %zu",
+ ALOGD("%s(%d): AUDIO_OUTPUT_FLAG_FAST denied by server; frameCount %zu -> %zu",
__func__, mPortId, mReqFrameCount, mFrameCount);
}
}
diff --git a/media/libaudiofoundation/Android.bp b/media/libaudiofoundation/Android.bp
index 93bc4d9..548b080 100644
--- a/media/libaudiofoundation/Android.bp
+++ b/media/libaudiofoundation/Android.bp
@@ -1,6 +1,8 @@
cc_library_headers {
name: "libaudiofoundation_headers",
vendor_available: true,
+ min_sdk_version: "29",
+
export_include_dirs: ["include"],
header_libs: [
"libaudio_system_headers",
diff --git a/media/libmedia/Android.bp b/media/libmedia/Android.bp
index be3f995..4925ea4 100644
--- a/media/libmedia/Android.bp
+++ b/media/libmedia/Android.bp
@@ -1,6 +1,8 @@
cc_library_headers {
name: "libmedia_headers",
vendor_available: true,
+ min_sdk_version: "29",
+
export_include_dirs: ["include"],
header_libs: [
"libbase_headers",
@@ -184,6 +186,8 @@
cc_library_static {
name: "libmedia_midiiowrapper",
+ min_sdk_version: "29",
+
srcs: ["MidiIoWrapper.cpp"],
static_libs: [
diff --git a/media/libmediahelper/Android.bp b/media/libmediahelper/Android.bp
index 72edeec..6fcbc7b 100644
--- a/media/libmediahelper/Android.bp
+++ b/media/libmediahelper/Android.bp
@@ -1,6 +1,7 @@
cc_library_headers {
name: "libmedia_helper_headers",
vendor_available: true,
+ min_sdk_version: "29",
export_include_dirs: ["include"],
}
diff --git a/media/libmediaplayerservice/StagefrightRecorder.cpp b/media/libmediaplayerservice/StagefrightRecorder.cpp
index cf7f423..7897959 100644
--- a/media/libmediaplayerservice/StagefrightRecorder.cpp
+++ b/media/libmediaplayerservice/StagefrightRecorder.cpp
@@ -2011,6 +2011,7 @@
}
if (mOutputFormat == OUTPUT_FORMAT_MPEG_4 || mOutputFormat == OUTPUT_FORMAT_THREE_GPP) {
(*meta)->setInt32(kKeyEmptyTrackMalFormed, true);
+ (*meta)->setInt32(kKey4BitTrackIds, true);
}
}
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerStreamListener.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerStreamListener.cpp
index b5142ed..a532603 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerStreamListener.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerStreamListener.cpp
@@ -34,8 +34,6 @@
mTargetHandler(targetHandler),
mEOS(false),
mSendDataNotification(true) {
- mSource->setListener(this);
-
mMemoryDealer = new MemoryDealer(kNumBuffers * kBufferSize);
for (size_t i = 0; i < kNumBuffers; ++i) {
sp<IMemory> mem = mMemoryDealer->allocate(kBufferSize);
diff --git a/media/libmediaplayerservice/nuplayer/StreamingSource.cpp b/media/libmediaplayerservice/nuplayer/StreamingSource.cpp
index 14f1323..bec27d3 100644
--- a/media/libmediaplayerservice/nuplayer/StreamingSource.cpp
+++ b/media/libmediaplayerservice/nuplayer/StreamingSource.cpp
@@ -79,6 +79,7 @@
void NuPlayer::StreamingSource::start() {
mStreamListener = new NuPlayerStreamListener(mSource, NULL);
+ mSource->setListener(mStreamListener);
uint32_t sourceFlags = mSource->flags();
diff --git a/media/libstagefright/Android.bp b/media/libstagefright/Android.bp
index a8fea90..3e49bae 100644
--- a/media/libstagefright/Android.bp
+++ b/media/libstagefright/Android.bp
@@ -2,10 +2,21 @@
name: "libstagefright_headers",
export_include_dirs: ["include"],
vendor_available: true,
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.media",
+ "com.android.media.swcodec",
+ ],
+ min_sdk_version: "29",
}
cc_library_static {
name: "libstagefright_esds",
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.media",
+ ],
+ min_sdk_version: "29",
srcs: ["ESDS.cpp"],
@@ -27,6 +38,11 @@
cc_library_static {
name: "libstagefright_metadatautils",
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.media",
+ ],
+ min_sdk_version: "29",
srcs: ["MetaDataUtils.cpp"],
@@ -94,6 +110,11 @@
cc_library_static {
name: "libstagefright_mpeg2extractor",
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.media",
+ ],
+ min_sdk_version: "29",
srcs: [
"Utils.cpp",
diff --git a/media/libstagefright/HevcUtils.cpp b/media/libstagefright/HevcUtils.cpp
index 482a1a7..b347453 100644
--- a/media/libstagefright/HevcUtils.cpp
+++ b/media/libstagefright/HevcUtils.cpp
@@ -83,6 +83,7 @@
}
if (err != OK) {
+ ALOGE("error parsing VPS or SPS or PPS");
return err;
}
diff --git a/media/libstagefright/MPEG4Writer.cpp b/media/libstagefright/MPEG4Writer.cpp
index af8096d..b902cbc 100644
--- a/media/libstagefright/MPEG4Writer.cpp
+++ b/media/libstagefright/MPEG4Writer.cpp
@@ -103,8 +103,40 @@
//#define SHOW_MODEL_BUILD 1
class MPEG4Writer::Track {
+ struct TrackId {
+ TrackId(uint32_t aId)
+ :mId(aId),
+ mTrackIdValid(false) {
+ }
+ bool isValid(bool akKey4BitTrackIds) {
+ // trackId cannot be zero, ISO/IEC 14496-12 8.3.2.3
+ if (mId == 0) {
+ return false;
+ }
+ /* MediaRecorder uses only 4 bit to represent track ids during notifying clients.
+ * MediaMuxer's track ids are restricted by container allowed size only.
+ * MPEG4 Container defines unsigned int (32), ISO/IEC 14496-12 8.3.2.2
+ */
+ if (akKey4BitTrackIds && mId > 15) {
+ return false;
+ }
+ mTrackIdValid = true;
+ return true;
+ }
+ uint32_t getId() const {
+ CHECK(mTrackIdValid);
+ return mId;
+ }
+ TrackId() = delete;
+ DISALLOW_EVIL_CONSTRUCTORS(TrackId);
+ private:
+ // unsigned int (32), ISO/IEC 14496-12 8.3.2.2
+ uint32_t mId;
+ bool mTrackIdValid;
+ };
+
public:
- Track(MPEG4Writer *owner, const sp<MediaSource> &source, size_t trackId);
+ Track(MPEG4Writer *owner, const sp<MediaSource> &source, uint32_t aTrackId);
~Track();
@@ -129,7 +161,7 @@
void addChunkOffset(off64_t offset);
void addItemOffsetAndSize(off64_t offset, size_t size, bool isExif);
void flushItemRefs();
- int32_t getTrackId() const { return mTrackId; }
+ TrackId& getTrackId() { return mTrackId; }
status_t dump(int fd, const Vector<String16>& args) const;
static const char *getFourCCForMime(const char *mime);
const char *getTrackType() const;
@@ -290,7 +322,7 @@
bool mIsMPEG4;
bool mGotStartKeyFrame;
bool mIsMalformed;
- int32_t mTrackId;
+ TrackId mTrackId;
int64_t mTrackDurationUs;
int64_t mMaxChunkDurationUs;
int64_t mLastDecodingTimeUs;
@@ -413,7 +445,7 @@
void addOneElstTableEntry(uint32_t segmentDuration, int32_t mediaTime,
int16_t mediaRate, int16_t mediaRateFraction);
- bool isTrackMalFormed() const;
+ bool isTrackMalFormed();
void sendTrackSummary(bool hasMultipleTracks);
// Write the boxes
@@ -534,7 +566,7 @@
release();
}
- if (fallocate(mFd, 0, 0, 1) == 0) {
+ if (fallocate(mFd, FALLOC_FL_KEEP_SIZE, 0, 1) == 0) {
ALOGD("PreAllocation enabled");
mPreAllocationEnabled = true;
} else {
@@ -744,8 +776,7 @@
// where 1MB is the common file size limit for MMS application.
// The default MAX _MOOV_BOX_SIZE value is based on about 3
// minute video recording with a bit rate about 3 Mbps, because
- // statistics also show that most of the video captured are going
- // to be less than 3 minutes.
+ // statistics show that most captured videos are less than 3 minutes.
// If the estimation is wrong, we will pay the price of wasting
// some reserved space. This should not happen so often statistically.
@@ -796,6 +827,15 @@
return size;
}
+status_t MPEG4Writer::validateAllTracksId(bool akKey4BitTrackIds) {
+ for (List<Track *>::iterator it = mTracks.begin(); it != mTracks.end(); ++it) {
+ if (!(*it)->getTrackId().isValid(akKey4BitTrackIds)) {
+ return BAD_VALUE;
+ }
+ }
+ return OK;
+}
+
status_t MPEG4Writer::start(MetaData *param) {
if (mInitCheck != OK) {
return UNKNOWN_ERROR;
@@ -810,6 +850,9 @@
mIsFileSizeLimitExplicitlyRequested = true;
}
+ /* mMaxFileSizeLimitBytes has to be set everytime fd is switched, hence the following code is
+ * appropriate in start() method.
+ */
int32_t fileSizeBits = fpathconf(mFd, _PC_FILESIZEBITS);
ALOGD("fpathconf _PC_FILESIZEBITS:%" PRId32, fileSizeBits);
fileSizeBits = std::min(fileSizeBits, 52 /* cap it below 4 peta bytes */);
@@ -944,6 +987,17 @@
setupAndStartLooper();
+ int32_t is4bitTrackId = false;
+ if (param && param->findInt32(kKey4BitTrackIds, &is4bitTrackId) && is4bitTrackId) {
+ err = validateAllTracksId(true);
+ }
+ else {
+ err = validateAllTracksId(false);
+ }
+ if (err != OK) {
+ return err;
+ }
+
err = startTracks(param);
if (err != OK) {
return err;
@@ -961,6 +1015,7 @@
status_t MPEG4Writer::stopWriterThread() {
ALOGV("Stopping writer thread");
if (!mWriterThreadStarted) {
+ ALOGD("Writer thread not started");
return OK;
}
{
@@ -975,7 +1030,8 @@
err = static_cast<status_t>(reinterpret_cast<uintptr_t>(dummy));
mWriterThreadStarted = false;
- WARN_UNLESS(err == 0, "stopWriterThread pthread_join retVal: %d, writer thread stopped", err);
+ WARN_UNLESS(err == 0, "stopWriterThread pthread_join retVal: %d", err);
+ ALOGD("Writer thread stopped");
return err;
}
@@ -1031,26 +1087,32 @@
writeInt32(0x40000000); // w
}
-void MPEG4Writer::release() {
+status_t MPEG4Writer::release() {
ALOGD("release()");
if (mPreAllocationEnabled) {
truncatePreAllocation();
}
+ int err = OK;
int retVal = fsync(mFd);
- WARN_UNLESS(retVal == 0, "fsync retVal:%d", retVal);
+ WARN_UNLESS(retVal == 0, "fsync err:%s(%d)", std::strerror(errno), errno);
+ err |= retVal;
retVal = close(mFd);
- WARN_UNLESS(retVal == 0, "close mFd retVal :%d", retVal);
+ WARN_UNLESS(retVal == 0, "close err:%s(%d)", std::strerror(errno), errno);
+ err |= retVal;
mFd = -1;
if (mNextFd != -1) {
retVal = close(mNextFd);
mNextFd = -1;
- WARN_UNLESS(retVal == 0, "close mNextFd retVal :%d", retVal);
+ WARN_UNLESS(retVal == 0, "close mNextFd error:%s(%d)",
+ std::strerror(errno), errno);
+ err |= retVal;
}
stopAndReleaseLooper();
mInitCheck = NO_INIT;
mStarted = false;
free(mInMemoryCache);
mInMemoryCache = NULL;
+ return err;
}
void MPEG4Writer::finishCurrentSession() {
@@ -1065,7 +1127,7 @@
}
if (mNextFd == -1) {
- ALOGW("No FileDescripter for next recording");
+ ALOGW("No FileDescriptor for next recording");
return INVALID_OPERATION;
}
@@ -1084,12 +1146,15 @@
} else {
if (!mWriterThreadStarted ||
!mStarted) {
- status_t err = OK;
+ status_t writerErr = OK;
if (mWriterThreadStarted) {
- err = stopWriterThread();
+ writerErr = stopWriterThread();
}
- release();
- return err;
+ status_t retErr = release();
+ if (writerErr != OK) {
+ retErr = writerErr;
+ }
+ return retErr;
}
}
@@ -1100,8 +1165,9 @@
for (List<Track *>::iterator it = mTracks.begin();
it != mTracks.end(); ++it) {
status_t trackErr = (*it)->stop(stopSource);
+ WARN_UNLESS(trackErr == 0, "%s track stopped with an error",
+ (*it)->getTrackType());
if (err == OK && trackErr != OK) {
- ALOGW("%s track stopped with an error", (*it)->getTrackType());
err = trackErr;
}
@@ -1118,7 +1184,6 @@
}
}
-
if (nonImageTrackCount > 1) {
ALOGD("Duration from tracks range is [%" PRId64 ", %" PRId64 "] us",
minDurationUs, maxDurationUs);
@@ -1126,13 +1191,15 @@
status_t writerErr = stopWriterThread();
- // TODO: which error to propagage, writerErr or trackErr?
+ // Propagating writer error
if (err == OK && writerErr != OK) {
err = writerErr;
}
// Do not write out movie header on error except malformed track.
+ // TODO: Remove samples of malformed tracks added in mdat.
if (err != OK && err != ERROR_MALFORMED) {
+ // Ignoring release() return value as there was an "err" already.
release();
return err;
}
@@ -1174,6 +1241,7 @@
} else {
ALOGI("The mp4 file will not be streamable.");
}
+ ALOGI("MOOV atom was written to the file");
}
mWriteBoxToMemory = false;
@@ -1186,7 +1254,7 @@
CHECK(mBoxes.empty());
- release();
+ err = release();
return err;
}
@@ -1354,7 +1422,7 @@
for (List<ChunkInfo>::iterator it = mChunkInfos.begin();
it != mChunkInfos.end(); ++it) {
- int trackNum = it->mTrack->getTrackId() << 28;
+ uint32_t trackNum = (it->mTrack->getTrackId().getId() << 28);
notify(MEDIA_RECORDER_TRACK_EVENT_INFO,
trackNum | MEDIA_RECORDER_TRACK_INTER_CHUNK_TIME_MS,
it->mMaxInterChunkDurUs);
@@ -1438,25 +1506,21 @@
void MPEG4Writer::addLengthPrefixedSample_l(MediaBuffer *buffer) {
size_t length = buffer->range_length();
if (mUse4ByteNalLength) {
- uint8_t x = length >> 24;
- writeOrPostError(mFd, &x, 1);
- x = (length >> 16) & 0xff;
- writeOrPostError(mFd, &x, 1);
- x = (length >> 8) & 0xff;
- writeOrPostError(mFd, &x, 1);
- x = length & 0xff;
- writeOrPostError(mFd, &x, 1);
-
+ uint8_t x[4];
+ x[0] = length >> 24;
+ x[1] = (length >> 16) & 0xff;
+ x[2] = (length >> 8) & 0xff;
+ x[3] = length & 0xff;
+ writeOrPostError(mFd, &x, 4);
writeOrPostError(mFd, (const uint8_t*)buffer->data() + buffer->range_offset(), length);
-
mOffset += length + 4;
} else {
CHECK_LT(length, 65536u);
- uint8_t x = length >> 8;
- writeOrPostError(mFd, &x, 1);
- x = length & 0xff;
- writeOrPostError(mFd, &x, 1);
+ uint8_t x[2];
+ x[0] = length >> 8;
+ x[1] = length & 0xff;
+ writeOrPostError(mFd, &x, 2);
writeOrPostError(mFd, (const uint8_t*)buffer->data() + buffer->range_offset(), length);
mOffset += length + 2;
}
@@ -1512,7 +1576,8 @@
std::strerror(errno), errno);
// Can't guarantee that file is usable or write would succeed anymore, hence signal to stop.
- sp<AMessage> msg = new AMessage(kWhatHandleIOError, mReflector);
+ sp<AMessage> msg = new AMessage(kWhatIOError, mReflector);
+ msg->setInt32("errno", errno);
status_t err = msg->post();
ALOGE("writeOrPostError post:%d", err);
}
@@ -1531,7 +1596,8 @@
offset, std::strerror(errno), errno);
// Can't guarantee that file is usable or seek would succeed anymore, hence signal to stop.
- sp<AMessage> msg = new AMessage(kWhatHandleIOError, mReflector);
+ sp<AMessage> msg = new AMessage(kWhatIOError, mReflector);
+ msg->setInt32("errno", errno);
status_t err = msg->post();
ALOGE("seekOrPostError post:%d", err);
}
@@ -1768,10 +1834,11 @@
ALOGV("preAllocateSize :%" PRIu64 " lastFileEndOffset:%" PRIu64, preAllocateSize,
lastFileEndOffset);
- int res = fallocate(mFd, 0, lastFileEndOffset, preAllocateSize);
+ int res = fallocate(mFd, FALLOC_FL_KEEP_SIZE, lastFileEndOffset, preAllocateSize);
if (res == -1) {
ALOGE("fallocate err:%s, %d, fd:%d", strerror(errno), errno, mFd);
- sp<AMessage> msg = new AMessage(kWhatHandleFallocateError, mReflector);
+ sp<AMessage> msg = new AMessage(kWhatFallocateError, mReflector);
+ msg->setInt32("errno", errno);
status_t err = msg->post();
mFallocateErr = true;
ALOGD("preAllocation post:%d", err);
@@ -1899,7 +1966,7 @@
////////////////////////////////////////////////////////////////////////////////
MPEG4Writer::Track::Track(
- MPEG4Writer *owner, const sp<MediaSource> &source, size_t trackId)
+ MPEG4Writer *owner, const sp<MediaSource> &source, uint32_t aTrackId)
: mOwner(owner),
mMeta(source->getFormat()),
mSource(source),
@@ -1909,7 +1976,7 @@
mStarted(false),
mGotStartKeyFrame(false),
mIsMalformed(false),
- mTrackId(trackId),
+ mTrackId(aTrackId),
mTrackDurationUs(0),
mEstimatedTrackSizeBytes(0),
mSamplesHaveSameSize(true),
@@ -2089,7 +2156,7 @@
void MPEG4Writer::setupAndStartLooper() {
if (mLooper == nullptr) {
mLooper = new ALooper;
- mLooper->setName("MP4WriterLooper");
+ mLooper->setName("MP4WtrCtrlHlpLooper");
mLooper->start();
mReflector = new AHandlerReflector<MPEG4Writer>(this);
mLooper->registerHandler(mReflector);
@@ -2099,12 +2166,12 @@
void MPEG4Writer::stopAndReleaseLooper() {
if (mLooper != nullptr) {
if (mReflector != nullptr) {
- ALOGD("unregisterHandler");
mLooper->unregisterHandler(mReflector->id());
mReflector.clear();
}
mLooper->stop();
mLooper.clear();
+ ALOGD("MP4WtrCtrlHlpLooper stopped");
}
}
@@ -2329,18 +2396,22 @@
break;
}
// ::write() or lseek64() wasn't a success, file could be malformed
- case kWhatHandleIOError: {
- ALOGE("kWhatHandleIOError");
+ case kWhatIOError: {
+ ALOGE("kWhatIOError");
+ int32_t err;
+ CHECK(msg->findInt32("errno", &err));
// Stop tracks' threads and main writer thread.
- notify(MEDIA_RECORDER_EVENT_ERROR, MEDIA_RECORDER_ERROR_UNKNOWN, ERROR_MALFORMED);
+ notify(MEDIA_RECORDER_EVENT_ERROR, MEDIA_RECORDER_ERROR_UNKNOWN, err);
stop();
break;
}
// fallocate() failed, hence notify app about it and stop().
- case kWhatHandleFallocateError: {
- ALOGE("kWhatHandleFallocateError");
- //TODO: introduce new MEDIA_RECORDER_INFO_STOPPED instead MEDIA_RECORDER_INFO_UNKNOWN?
- notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_INFO_UNKNOWN, ERROR_IO);
+ case kWhatFallocateError: {
+ ALOGE("kWhatFallocateError");
+ int32_t err;
+ CHECK(msg->findInt32("errno", &err));
+ //TODO: introduce a suitable MEDIA_RECORDER_ERROR_* instead MEDIA_RECORDER_ERROR_UNKNOWN?
+ notify(MEDIA_RECORDER_EVENT_ERROR, MEDIA_RECORDER_ERROR_UNKNOWN, err);
stop();
break;
}
@@ -2708,9 +2779,9 @@
void *dummy;
status_t err = pthread_join(mThread, &dummy);
WARN_UNLESS(err == 0, "track::stop: pthread_join status:%d", err);
- err = static_cast<status_t>(reinterpret_cast<uintptr_t>(dummy));
- WARN_UNLESS(err == 0, "%s track stopped. Status :%d. %s source", getTrackType(), err,
- stopSource ? "Stop" : "Not Stop");
+ status_t threadRetVal = static_cast<status_t>(reinterpret_cast<uintptr_t>(dummy));
+ WARN_UNLESS(threadRetVal == 0, "%s track stopped. Status :%d. %s source",
+ getTrackType(), err, stopSource ? "Stop" : "Not Stop");
mStarted = false;
return err;
}
@@ -2849,6 +2920,7 @@
}
if (nextStartCode == NULL) {
+ ALOGE("nextStartCode is null");
return ERROR_MALFORMED;
}
@@ -3126,11 +3198,11 @@
int64_t lastSampleDurationTicks = -1; // Timescale based ticks
if (mIsAudio) {
- prctl(PR_SET_NAME, (unsigned long)"AudioTrackWriterThread", 0, 0, 0);
+ prctl(PR_SET_NAME, (unsigned long)"MP4WtrAudTrkThread", 0, 0, 0);
} else if (mIsVideo) {
- prctl(PR_SET_NAME, (unsigned long)"VideoTrackWriterThread", 0, 0, 0);
+ prctl(PR_SET_NAME, (unsigned long)"MP4WtrVidTrkThread", 0, 0, 0);
} else {
- prctl(PR_SET_NAME, (unsigned long)"MetadataTrackWriterThread", 0, 0, 0);
+ prctl(PR_SET_NAME, (unsigned long)"MP4WtrMetaTrkThread", 0, 0, 0);
}
if (mOwner->isRealTimeRecording()) {
@@ -3181,6 +3253,7 @@
}
++count;
+
int32_t isCodecConfig;
if (buffer->meta_data().findInt32(kKeyIsCodecConfig, &isCodecConfig)
&& isCodecConfig) {
@@ -3204,7 +3277,7 @@
+ buffer->range_offset(),
buffer->range_length());
} else if (mIsMPEG4) {
- copyCodecSpecificData((const uint8_t *)buffer->data() + buffer->range_offset(),
+ err = copyCodecSpecificData((const uint8_t *)buffer->data() + buffer->range_offset(),
buffer->range_length());
}
}
@@ -3213,8 +3286,10 @@
buffer = NULL;
if (OK != err) {
mSource->stop();
+ mIsMalformed = true;
+ uint32_t trackNum = (mTrackId.getId() << 28);
mOwner->notify(MEDIA_RECORDER_TRACK_EVENT_ERROR,
- mTrackId | MEDIA_RECORDER_TRACK_ERROR_GENERAL, err);
+ trackNum | MEDIA_RECORDER_TRACK_ERROR_GENERAL, err);
break;
}
@@ -3251,7 +3326,7 @@
* Reserve space in the file for the current sample + to be written MOOV box. If reservation
* for a new sample fails, preAllocate(...) stops muxing session completely. Stop() could
* write MOOV box successfully as space for the same was reserved in the prior call.
- * Release the current buffer/sample only here.
+ * Release the current buffer/sample here.
*/
if (!mOwner->preAllocate(buffer->range_length())) {
buffer->release();
@@ -3291,6 +3366,7 @@
updateTrackSizeEstimate();
if (mOwner->exceedsFileSizeLimit()) {
+ copy->release();
if (mOwner->switchFd() != OK) {
ALOGW("Recorded file size exceeds limit %" PRId64 "bytes",
mOwner->mMaxFileSizeLimitBytes);
@@ -3301,16 +3377,15 @@
ALOGV("%s Current recorded file size exceeds limit %" PRId64 "bytes. Switching output",
getTrackType(), mOwner->mMaxFileSizeLimitBytes);
}
- copy->release();
break;
}
if (mOwner->exceedsFileDurationLimit()) {
ALOGW("Recorded file duration exceeds limit %" PRId64 "microseconds",
mOwner->mMaxFileDurationLimitUs);
- mOwner->notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_INFO_MAX_DURATION_REACHED, 0);
copy->release();
mSource->stop();
+ mOwner->notify(MEDIA_RECORDER_EVENT_INFO, MEDIA_RECORDER_INFO_MAX_DURATION_REACHED, 0);
break;
}
@@ -3592,13 +3667,13 @@
}
}
}
+
if (isTrackMalFormed()) {
- mIsMalformed = true;
dumpTimeStamps();
err = ERROR_MALFORMED;
}
- mOwner->trackProgressStatus(mTrackId, -1, err);
+ mOwner->trackProgressStatus(mTrackId.getId(), -1, err);
// Add final entries only for non-empty tracks.
if (mStszTableEntries->count() > 0) {
@@ -3665,7 +3740,7 @@
return err;
}
-bool MPEG4Writer::Track::isTrackMalFormed() const {
+bool MPEG4Writer::Track::isTrackMalFormed() {
if (mIsMalformed) {
return true;
}
@@ -3674,23 +3749,29 @@
if (mOwner->mStartMeta &&
mOwner->mStartMeta->findInt32(kKeyEmptyTrackMalFormed, &emptyTrackMalformed) &&
emptyTrackMalformed) {
+ // MediaRecorder(sets kKeyEmptyTrackMalFormed by default) report empty tracks as malformed.
if (!mIsHeic && mStszTableEntries->count() == 0) { // no samples written
ALOGE("The number of recorded samples is 0");
+ mIsMalformed = true;
return true;
}
if (mIsVideo && mStssTableEntries->count() == 0) { // no sync frames for video
ALOGE("There are no sync frames for video track");
+ mIsMalformed = true;
return true;
}
} else {
- // No sync frames for video.
+ // Through MediaMuxer, empty tracks can be added. No sync frames for video.
if (mIsVideo && mStszTableEntries->count() > 0 && mStssTableEntries->count() == 0) {
ALOGE("There are no sync frames for video track");
+ mIsMalformed = true;
return true;
}
}
-
- if (OK != checkCodecSpecificData()) { // no codec specific data
+ // Don't check for CodecSpecificData when track is empty.
+ if (mStszTableEntries->count() > 0 && OK != checkCodecSpecificData()) {
+ // No codec specific data.
+ mIsMalformed = true;
return true;
}
@@ -3704,7 +3785,7 @@
return;
}
- int trackNum = (mTrackId << 28);
+ uint32_t trackNum = (mTrackId.getId() << 28);
mOwner->notify(MEDIA_RECORDER_TRACK_EVENT_INFO,
trackNum | MEDIA_RECORDER_TRACK_INFO_TYPE,
@@ -3758,15 +3839,15 @@
if (mTrackEveryTimeDurationUs > 0 &&
timeUs - mPreviousTrackTimeUs >= mTrackEveryTimeDurationUs) {
ALOGV("Fire time tracking progress status at %" PRId64 " us", timeUs);
- mOwner->trackProgressStatus(mTrackId, timeUs - mPreviousTrackTimeUs, err);
+ mOwner->trackProgressStatus(mTrackId.getId(), timeUs - mPreviousTrackTimeUs, err);
mPreviousTrackTimeUs = timeUs;
}
}
void MPEG4Writer::trackProgressStatus(
- size_t trackId, int64_t timeUs, status_t err) {
+ uint32_t trackId, int64_t timeUs, status_t err) {
Mutex::Autolock lock(mLock);
- int32_t trackNum = (trackId << 28);
+ uint32_t trackNum = (trackId << 28);
// Error notification
// Do not consider ERROR_END_OF_STREAM an error
@@ -3936,8 +4017,8 @@
void MPEG4Writer::Track::writeStblBox() {
mOwner->beginBox("stbl");
- // Add subboxes only for non-empty tracks.
- if (mStszTableEntries->count() > 0) {
+ // Add subboxes for only non-empty and well-formed tracks.
+ if (mStszTableEntries->count() > 0 && !isTrackMalFormed()) {
mOwner->beginBox("stsd");
mOwner->writeInt32(0); // version=0, flags=0
mOwner->writeInt32(1); // entry count
@@ -4242,7 +4323,7 @@
mOwner->writeInt32(0x07); // version=0, flags=7
mOwner->writeInt32(now); // creation time
mOwner->writeInt32(now); // modification time
- mOwner->writeInt32(mTrackId); // track id starts with 1
+ mOwner->writeInt32(mTrackId.getId()); // track id starts with 1
mOwner->writeInt32(0); // reserved
int64_t trakDurationUs = getDurationUs();
int32_t mvhdTimeScale = mOwner->getTimeScale();
diff --git a/media/libstagefright/MediaMuxer.cpp b/media/libstagefright/MediaMuxer.cpp
index 1cb45ac..809f298 100644
--- a/media/libstagefright/MediaMuxer.cpp
+++ b/media/libstagefright/MediaMuxer.cpp
@@ -171,7 +171,10 @@
if (err != OK || mError != OK) {
ALOGE("stop err: %d, mError:%d", err, mError);
}
- // Prioritize mError over err.
+ /* Prioritize mError over err as writer would have got stopped on any
+ * internal error and notified muxer already. Clients might issue
+ * stop again later, and mWriter->stop() would return success.
+ */
if (mError != OK) {
err = mError;
}
diff --git a/media/libstagefright/bqhelper/Android.bp b/media/libstagefright/bqhelper/Android.bp
index 37e842a..8698d33 100644
--- a/media/libstagefright/bqhelper/Android.bp
+++ b/media/libstagefright/bqhelper/Android.bp
@@ -63,6 +63,8 @@
vndk: {
enabled: true,
},
+ min_sdk_version: "29",
+
shared_libs: [ "libgui" ],
target: {
vendor: {
diff --git a/media/libstagefright/codecs/m4v_h263/dec/Android.bp b/media/libstagefright/codecs/m4v_h263/dec/Android.bp
index c67dc2b..4303565 100644
--- a/media/libstagefright/codecs/m4v_h263/dec/Android.bp
+++ b/media/libstagefright/codecs/m4v_h263/dec/Android.bp
@@ -1,6 +1,11 @@
cc_library_static {
name: "libstagefright_m4vh263dec",
vendor_available: true,
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.media.swcodec",
+ ],
+ min_sdk_version: "29",
shared_libs: ["liblog"],
srcs: [
diff --git a/media/libstagefright/codecs/m4v_h263/enc/Android.bp b/media/libstagefright/codecs/m4v_h263/enc/Android.bp
index 846f614..b8bc24e 100644
--- a/media/libstagefright/codecs/m4v_h263/enc/Android.bp
+++ b/media/libstagefright/codecs/m4v_h263/enc/Android.bp
@@ -1,6 +1,11 @@
cc_library_static {
name: "libstagefright_m4vh263enc",
vendor_available: true,
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.media.swcodec",
+ ],
+ min_sdk_version: "29",
srcs: [
"src/bitstream_io.cpp",
diff --git a/media/libstagefright/foundation/Android.bp b/media/libstagefright/foundation/Android.bp
index 9fe879e..f440e00 100644
--- a/media/libstagefright/foundation/Android.bp
+++ b/media/libstagefright/foundation/Android.bp
@@ -3,6 +3,7 @@
export_include_dirs: ["include"],
vendor_available: true,
host_supported: true,
+ min_sdk_version: "29",
}
cc_defaults {
@@ -101,11 +102,13 @@
cc_library {
name: "libstagefright_foundation",
defaults: ["libstagefright_foundation_defaults"],
+ min_sdk_version: "29",
}
cc_library_static {
name: "libstagefright_foundation_without_imemory",
defaults: ["libstagefright_foundation_defaults"],
+ min_sdk_version: "29",
cflags: [
"-Wno-multichar",
diff --git a/media/libstagefright/id3/Android.bp b/media/libstagefright/id3/Android.bp
index c8173cf..db37fe9 100644
--- a/media/libstagefright/id3/Android.bp
+++ b/media/libstagefright/id3/Android.bp
@@ -1,5 +1,6 @@
cc_library_static {
name: "libstagefright_id3",
+ min_sdk_version: "29",
srcs: ["ID3.cpp"],
diff --git a/media/libstagefright/include/media/stagefright/MPEG4Writer.h b/media/libstagefright/include/media/stagefright/MPEG4Writer.h
index 34a7d55..e048f07 100644
--- a/media/libstagefright/include/media/stagefright/MPEG4Writer.h
+++ b/media/libstagefright/include/media/stagefright/MPEG4Writer.h
@@ -85,9 +85,9 @@
friend struct AHandlerReflector<MPEG4Writer>;
enum {
- kWhatSwitch = 'swch',
- kWhatHandleIOError = 'ioer',
- kWhatHandleFallocateError = 'faer'
+ kWhatSwitch = 'swch',
+ kWhatIOError = 'ioer',
+ kWhatFallocateError = 'faer'
};
int mFd;
@@ -287,7 +287,8 @@
bool exceedsFileDurationLimit();
bool approachingFileSizeLimit();
bool isFileStreamable() const;
- void trackProgressStatus(size_t trackId, int64_t timeUs, status_t err = OK);
+ void trackProgressStatus(uint32_t trackId, int64_t timeUs, status_t err = OK);
+ status_t validateAllTracksId(bool akKey4BitTrackIds);
void writeCompositionMatrix(int32_t degrees);
void writeMvhdBox(int64_t durationUs);
void writeMoovBox(int64_t durationUs);
@@ -310,7 +311,7 @@
*/
bool preAllocate(uint64_t wantSize);
/*
- * Truncate file as per the size used for meta data and actual data in a session.
+ * Truncate file as per the size used for metadata and actual data in a session.
*/
bool truncatePreAllocation();
@@ -327,7 +328,7 @@
void writeFileLevelMetaBox();
void sendSessionSummary();
- void release();
+ status_t release();
status_t switchFd();
status_t reset(bool stopSource = true);
diff --git a/media/libstagefright/include/media/stagefright/MetaDataBase.h b/media/libstagefright/include/media/stagefright/MetaDataBase.h
index 3b701f6..64eb8b4 100644
--- a/media/libstagefright/include/media/stagefright/MetaDataBase.h
+++ b/media/libstagefright/include/media/stagefright/MetaDataBase.h
@@ -239,6 +239,12 @@
kKeyHapticChannelCount = 'hapC',
+ /* MediaRecorder.h, error notifications can represent track ids with 4 bits only.
+ * | track id | reserved | error or info type |
+ * 31 28 16 0
+ */
+ kKey4BitTrackIds = '4bid',
+
// Treat empty track as malformed for MediaRecorder.
kKeyEmptyTrackMalFormed = 'nemt', // bool (int32_t)
};
diff --git a/media/libwatchdog/Android.bp b/media/libwatchdog/Android.bp
index 2aefa7d..1a87824 100644
--- a/media/libwatchdog/Android.bp
+++ b/media/libwatchdog/Android.bp
@@ -31,4 +31,5 @@
},
},
apex_available: ["com.android.media"],
+ min_sdk_version: "29",
}
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index a04a962..a2f8230 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -35,6 +35,12 @@
cc_library_headers {
name: "media_ndk_headers",
vendor_available: true,
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.media",
+ "com.android.media.swcodec",
+ ],
+ min_sdk_version: "29",
export_include_dirs: ["include"]
}
diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp
index c9d2c68..bac9430 100644
--- a/services/camera/libcameraservice/CameraService.cpp
+++ b/services/camera/libcameraservice/CameraService.cpp
@@ -467,10 +467,21 @@
logDeviceRemoved(idCombo,
String8::format("Device status changed to %d", newStatus));
}
-
+ // Avoid calling getSystemCameraKind() with mStatusListenerLock held (b/141756275)
+ SystemCameraKind deviceKind = SystemCameraKind::PUBLIC;
+ if (getSystemCameraKind(id, &deviceKind) != OK) {
+ ALOGE("%s: Invalid camera id %s, skipping", __FUNCTION__, id.string());
+ return;
+ }
String16 id16(id), physicalId16(physicalId);
Mutex::Autolock lock(mStatusListenerLock);
for (auto& listener : mListenerList) {
+ if (shouldSkipStatusUpdates(deviceKind, listener->isVendorListener(),
+ listener->getListenerPid(), listener->getListenerUid())) {
+ ALOGV("Skipping discovery callback for system-only camera device %s",
+ id.c_str());
+ continue;
+ }
listener->getListener()->onPhysicalCameraStatusChanged(mapToInterface(newStatus),
id16, physicalId16);
}
@@ -3757,13 +3768,13 @@
Mutex::Autolock lock(mStatusListenerLock);
- notifyPhysicalCameraStatusLocked(mapToInterface(status), cameraId);
+ notifyPhysicalCameraStatusLocked(mapToInterface(status), cameraId, deviceKind);
for (auto& listener : mListenerList) {
bool isVendorListener = listener->isVendorListener();
if (shouldSkipStatusUpdates(deviceKind, isVendorListener,
listener->getListenerPid(), listener->getListenerUid()) ||
- (isVendorListener && !supportsHAL3)) {
+ (isVendorListener && !supportsHAL3)) {
ALOGV("Skipping discovery callback for system-only camera/HAL1 device %s",
cameraId.c_str());
continue;
@@ -3875,7 +3886,8 @@
return OK;
}
-void CameraService::notifyPhysicalCameraStatusLocked(int32_t status, const String8& cameraId) {
+void CameraService::notifyPhysicalCameraStatusLocked(int32_t status, const String8& cameraId,
+ SystemCameraKind deviceKind) {
Mutex::Autolock lock(mCameraStatesLock);
for (const auto& state : mCameraStates) {
std::vector<std::string> physicalCameraIds;
@@ -3891,6 +3903,12 @@
String16 id16(state.first), physicalId16(cameraId);
for (auto& listener : mListenerList) {
+ if (shouldSkipStatusUpdates(deviceKind, listener->isVendorListener(),
+ listener->getListenerPid(), listener->getListenerUid())) {
+ ALOGV("Skipping discovery callback for system-only camera device %s",
+ cameraId.c_str());
+ continue;
+ }
listener->getListener()->onPhysicalCameraStatusChanged(status,
id16, physicalId16);
}
diff --git a/services/camera/libcameraservice/CameraService.h b/services/camera/libcameraservice/CameraService.h
index 18cf77a..4321201 100644
--- a/services/camera/libcameraservice/CameraService.h
+++ b/services/camera/libcameraservice/CameraService.h
@@ -1005,7 +1005,8 @@
hardware::camera::common::V1_0::TorchModeStatus status);
// notify physical camera status when the physical camera is public.
- void notifyPhysicalCameraStatusLocked(int32_t status, const String8& cameraId);
+ void notifyPhysicalCameraStatusLocked(int32_t status, const String8& cameraId,
+ SystemCameraKind deviceKind);
// IBinder::DeathRecipient implementation
virtual void binderDied(const wp<IBinder> &who);
diff --git a/services/mediacodec/Android.bp b/services/mediacodec/Android.bp
index 4bf103c..f4c1924 100644
--- a/services/mediacodec/Android.bp
+++ b/services/mediacodec/Android.bp
@@ -1,6 +1,7 @@
cc_binary {
name: "mediaswcodec",
vendor_available: true,
+ min_sdk_version: "29",
srcs: [
"main_swcodecservice.cpp",
diff --git a/services/mediametrics/Android.bp b/services/mediametrics/Android.bp
index c87fbd9..645d151 100644
--- a/services/mediametrics/Android.bp
+++ b/services/mediametrics/Android.bp
@@ -1,8 +1,94 @@
// Media Statistics service
//
+tidy_errors = [
+ // https://clang.llvm.org/extra/clang-tidy/checks/list.html
+ // For many categories, the checks are too many to specify individually.
+ // Feel free to disable as needed - as warnings are generally ignored,
+ // we treat warnings as errors.
+ "android-*",
+ "bugprone-*",
+ "cert-*",
+ "clang-analyzer-security*",
+ "google-*",
+ "misc-*",
+ //"modernize-*", // explicitly list the modernize as they can be subjective.
+ "modernize-avoid-bind",
+ //"modernize-avoid-c-arrays", // std::array<> can be verbose
+ "modernize-concat-nested-namespaces",
+ //"modernize-deprecated-headers", // C headers still ok even if there is C++ equivalent.
+ "modernize-deprecated-ios-base-aliases",
+ "modernize-loop-convert",
+ "modernize-make-shared",
+ "modernize-make-unique",
+ "modernize-pass-by-value",
+ "modernize-raw-string-literal",
+ "modernize-redundant-void-arg",
+ "modernize-replace-auto-ptr",
+ "modernize-replace-random-shuffle",
+ "modernize-return-braced-init-list",
+ "modernize-shrink-to-fit",
+ "modernize-unary-static-assert",
+ "modernize-use-auto", // debatable - auto can obscure type
+ "modernize-use-bool-literals",
+ "modernize-use-default-member-init",
+ "modernize-use-emplace",
+ "modernize-use-equals-default",
+ "modernize-use-equals-delete",
+ "modernize-use-nodiscard",
+ "modernize-use-noexcept",
+ "modernize-use-nullptr",
+ "modernize-use-override",
+ //"modernize-use-trailing-return-type", // not necessarily more readable
+ "modernize-use-transparent-functors",
+ "modernize-use-uncaught-exceptions",
+ "modernize-use-using",
+ "performance-*",
+
+ // Remove some pedantic stylistic requirements.
+ "-google-readability-casting", // C++ casts not always necessary and may be verbose
+ "-google-readability-todo", // do not require TODO(info)
+]
+
+cc_defaults {
+ name: "mediametrics_flags_defaults",
+ // https://clang.llvm.org/docs/UsersManual.html#command-line-options
+ // https://clang.llvm.org/docs/DiagnosticsReference.html
+ cflags: [
+ "-Wall",
+ "-Wdeprecated",
+ "-Werror",
+ "-Werror=implicit-fallthrough",
+ "-Werror=sometimes-uninitialized",
+ "-Werror=conditional-uninitialized",
+ "-Wextra",
+ "-Wredundant-decls",
+ "-Wshadow",
+ "-Wstrict-aliasing",
+ "-fstrict-aliasing",
+ "-Wthread-safety",
+ //"-Wthread-safety-negative", // experimental - looks broken in R.
+ "-Wunreachable-code",
+ "-Wunreachable-code-break",
+ "-Wunreachable-code-return",
+ "-Wunused",
+ "-Wused-but-marked-unused",
+ ],
+ // https://clang.llvm.org/extra/clang-tidy/
+ tidy: true,
+ tidy_checks: tidy_errors,
+ tidy_checks_as_errors: tidy_errors,
+ tidy_flags: [
+ "-format-style='file'",
+ "--header-filter='frameworks/av/services/mediametrics/'",
+ ],
+}
+
cc_binary {
name: "mediametrics",
+ defaults: [
+ "mediametrics_flags_defaults",
+ ],
srcs: [
"main_mediametrics.cpp",
@@ -22,17 +108,13 @@
init_rc: [
"mediametrics.rc",
],
-
- cflags: [
- "-Wall",
- "-Werror",
- "-Wextra",
- "-Wthread-safety",
- ],
}
cc_library_shared {
name: "libmediametricsservice",
+ defaults: [
+ "mediametrics_flags_defaults",
+ ],
srcs: [
"AudioAnalytics.cpp",
@@ -73,11 +155,4 @@
include_dirs: [
"system/media/audio_utils/include",
],
-
- cflags: [
- "-Wall",
- "-Werror",
- "-Wextra",
- "-Wthread-safety",
- ],
}
diff --git a/services/mediametrics/AudioAnalytics.cpp b/services/mediametrics/AudioAnalytics.cpp
index 6138d32..31ad234 100644
--- a/services/mediametrics/AudioAnalytics.cpp
+++ b/services/mediametrics/AudioAnalytics.cpp
@@ -594,4 +594,4 @@
#endif
}
-} // namespace android
+} // namespace android::mediametrics
diff --git a/services/mediametrics/AudioPowerUsage.cpp b/services/mediametrics/AudioPowerUsage.cpp
index b1615bd..b1648d9 100644
--- a/services/mediametrics/AudioPowerUsage.cpp
+++ b/services/mediametrics/AudioPowerUsage.cpp
@@ -160,7 +160,7 @@
return true; //ignore unknown device
}
- for (auto item : mItems) {
+ for (const auto& item : mItems) {
int32_t item_type = 0, item_device = 0;
double item_volume = 0.;
int64_t item_duration_ns = 0;
@@ -259,8 +259,8 @@
const int64_t endCallNs = item->getTimestamp();
const int64_t durationNs = endCallNs - mDeviceTimeNs;
if (durationNs > 0) {
- mDeviceVolume = (mDeviceVolume * (mVolumeTimeNs - mDeviceTimeNs) +
- mVoiceVolume * (endCallNs - mVolumeTimeNs)) / durationNs;
+ mDeviceVolume = (mDeviceVolume * double(mVolumeTimeNs - mDeviceTimeNs) +
+ mVoiceVolume * double(endCallNs - mVolumeTimeNs)) / durationNs;
saveAsItem_l(mPrimaryDevice, durationNs, VOICE_CALL_TYPE, mDeviceVolume);
}
} else if (mode == "AUDIO_MODE_IN_CALL") { // entering call mode
@@ -287,8 +287,8 @@
const int64_t timeNs = item->getTimestamp();
const int64_t durationNs = timeNs - mDeviceTimeNs;
if (durationNs > 0) {
- mDeviceVolume = (mDeviceVolume * (mVolumeTimeNs - mDeviceTimeNs) +
- mVoiceVolume * (timeNs - mVolumeTimeNs)) / durationNs;
+ mDeviceVolume = (mDeviceVolume * double(mVolumeTimeNs - mDeviceTimeNs) +
+ mVoiceVolume * double(timeNs - mVolumeTimeNs)) / durationNs;
mVolumeTimeNs = timeNs;
}
}
@@ -318,8 +318,8 @@
const int64_t endDeviceNs = item->getTimestamp();
const int64_t durationNs = endDeviceNs - mDeviceTimeNs;
if (durationNs > 0) {
- mDeviceVolume = (mDeviceVolume * (mVolumeTimeNs - mDeviceTimeNs) +
- mVoiceVolume * (endDeviceNs - mVolumeTimeNs)) / durationNs;
+ mDeviceVolume = (mDeviceVolume * double(mVolumeTimeNs - mDeviceTimeNs) +
+ mVoiceVolume * double(endDeviceNs - mVolumeTimeNs)) / durationNs;
saveAsItem_l(mPrimaryDevice, durationNs, VOICE_CALL_TYPE, mDeviceVolume);
}
// reset statistics
@@ -391,4 +391,4 @@
return { ss.str(), slot };
}
-} // namespace android
+} // namespace android::mediametrics
diff --git a/services/mediametrics/MediaMetricsService.cpp b/services/mediametrics/MediaMetricsService.cpp
index 3b3dc3e..584bd13 100644
--- a/services/mediametrics/MediaMetricsService.cpp
+++ b/services/mediametrics/MediaMetricsService.cpp
@@ -32,7 +32,8 @@
namespace android {
-using namespace mediametrics;
+using mediametrics::Item;
+using mediametrics::startsWith;
// individual records kept in memory: age or count
// age: <= 28 hours (1 1/6 days)
@@ -63,7 +64,7 @@
bool MediaMetricsService::useUidForPackage(
const std::string& package, const std::string& installer)
{
- if (strchr(package.c_str(), '.') == NULL) {
+ if (strchr(package.c_str(), '.') == nullptr) {
return false; // not of form 'com.whatever...'; assume internal and ok
} else if (strncmp(package.c_str(), "android.", 8) == 0) {
return false; // android.* packages are assumed fine
@@ -203,9 +204,9 @@
// Overwrite package name and version if the caller was untrusted or empty
if (!isTrusted || item->getPkgName().empty()) {
- const uid_t uid = item->getUid();
+ const uid_t uidItem = item->getUid();
const auto [ pkgName, version ] =
- MediaMetricsService::getSanitizedPackageNameAndVersionCode(uid);
+ MediaMetricsService::getSanitizedPackageNameAndVersionCode(uidItem);
item->setPkgName(pkgName);
item->setPkgVersionCode(version);
}
@@ -320,7 +321,7 @@
String8 value(args[i]);
char *endp;
const char *p = value.string();
- long long sec = strtoll(p, &endp, 10);
+ const auto sec = (int64_t)strtoll(p, &endp, 10);
if (endp == p || *endp != '\0' || sec == 0) {
sinceNs = 0;
} else if (sec < 0) {
diff --git a/services/mediametrics/TimeMachine.h b/services/mediametrics/TimeMachine.h
index c82778b..00a44a4 100644
--- a/services/mediametrics/TimeMachine.h
+++ b/services/mediametrics/TimeMachine.h
@@ -18,6 +18,7 @@
#include <any>
#include <map>
+#include <mutex>
#include <sstream>
#include <string>
#include <variant>
@@ -81,6 +82,8 @@
, mCreationTime(time)
, mLastModificationTime(time)
{
+ (void)mCreationTime; // suppress unused warning.
+
// allowUid allows an untrusted client with a matching uid to set properties
// in this key.
// If allowUid == (uid_t)-1, no untrusted client may set properties in the key.
@@ -209,7 +212,7 @@
const std::string mKey;
const uid_t mAllowUid;
- const int64_t mCreationTime __unused;
+ const int64_t mCreationTime;
int64_t mLastModificationTime;
std::map<std::string /* property */, PropertyHistory> mPropertyMap;
@@ -442,7 +445,7 @@
++it) {
if (ll <= 0) break;
if (prefix != nullptr && !startsWith(it->first, prefix)) break;
- std::lock_guard lock(getLockForKey(it->first));
+ std::lock_guard lock2(getLockForKey(it->first));
auto [s, l] = it->second->dump(ll, sinceNs);
ss << s;
ll -= l;
diff --git a/services/mediametrics/iface_statsd.cpp b/services/mediametrics/iface_statsd.cpp
index 3a1eea7..6e51f72 100644
--- a/services/mediametrics/iface_statsd.cpp
+++ b/services/mediametrics/iface_statsd.cpp
@@ -71,7 +71,7 @@
// give me a record, i'll look at the type and upload appropriately
bool dump2Statsd(const std::shared_ptr<const mediametrics::Item>& item) {
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// get the key
std::string key = item->getKey();
diff --git a/services/mediametrics/main_mediametrics.cpp b/services/mediametrics/main_mediametrics.cpp
index 6992c32..3a66538 100644
--- a/services/mediametrics/main_mediametrics.cpp
+++ b/services/mediametrics/main_mediametrics.cpp
@@ -25,9 +25,9 @@
#include <binder/ProcessState.h>
#include <mediautils/LimitProcessMemory.h>
-int main(int argc __unused, char **argv __unused)
+int main(int argc __unused, char **argv)
{
- using namespace android;
+ using namespace android; // NOLINT (clang-tidy)
limitProcessMemory(
"media.metrics.maxmem", /* property that defines limit */
@@ -39,7 +39,8 @@
// to match the service name
// we're replacing "/system/bin/mediametrics" with "media.metrics"
// we add a ".", but discard the path components: we finish with a shorter string
- strcpy(argv[0], MediaMetricsService::kServiceName);
+ const size_t origSize = strlen(argv[0]) + 1; // include null termination.
+ strlcpy(argv[0], MediaMetricsService::kServiceName, origSize);
defaultServiceManager()->addService(
String16(MediaMetricsService::kServiceName), new MediaMetricsService());
diff --git a/services/mediametrics/statsd_audiopolicy.cpp b/services/mediametrics/statsd_audiopolicy.cpp
index 634c801..393c6ae 100644
--- a/services/mediametrics/statsd_audiopolicy.cpp
+++ b/services/mediametrics/statsd_audiopolicy.cpp
@@ -39,7 +39,7 @@
bool statsd_audiopolicy(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -122,4 +122,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/mediametrics/statsd_audiorecord.cpp b/services/mediametrics/statsd_audiorecord.cpp
index 69d1661..43feda1 100644
--- a/services/mediametrics/statsd_audiorecord.cpp
+++ b/services/mediametrics/statsd_audiorecord.cpp
@@ -39,7 +39,7 @@
bool statsd_audiorecord(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -155,4 +155,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/mediametrics/statsd_audiothread.cpp b/services/mediametrics/statsd_audiothread.cpp
index 300151b..e867f5b 100644
--- a/services/mediametrics/statsd_audiothread.cpp
+++ b/services/mediametrics/statsd_audiothread.cpp
@@ -39,7 +39,7 @@
bool statsd_audiothread(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -204,4 +204,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/mediametrics/statsd_audiotrack.cpp b/services/mediametrics/statsd_audiotrack.cpp
index 397cdf3..ee5b9b2 100644
--- a/services/mediametrics/statsd_audiotrack.cpp
+++ b/services/mediametrics/statsd_audiotrack.cpp
@@ -39,7 +39,7 @@
bool statsd_audiotrack(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -146,4 +146,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/mediametrics/statsd_codec.cpp b/services/mediametrics/statsd_codec.cpp
index f5fa57e..7a38c7c 100644
--- a/services/mediametrics/statsd_codec.cpp
+++ b/services/mediametrics/statsd_codec.cpp
@@ -39,7 +39,7 @@
bool statsd_codec(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -188,4 +188,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/mediametrics/statsd_drm.cpp b/services/mediametrics/statsd_drm.cpp
index 4f2e861..89d6f8f 100644
--- a/services/mediametrics/statsd_drm.cpp
+++ b/services/mediametrics/statsd_drm.cpp
@@ -43,22 +43,22 @@
// mediadrm
bool statsd_mediadrm(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ 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;
- char *vendor = NULL;
+ char *vendor = nullptr;
(void) item->getCString("vendor", &vendor);
- char *description = NULL;
+ char *description = nullptr;
(void) item->getCString("description", &description);
- char *serialized_metrics = NULL;
+ char *serialized_metrics = nullptr;
(void) item->getCString("serialized_metrics", &serialized_metrics);
if (enabled_statsd) {
- android::util::BytesField bf_serialized(serialized_metrics ? serialized_metrics : NULL,
+ android::util::BytesField bf_serialized(serialized_metrics ? serialized_metrics : nullptr,
serialized_metrics ? strlen(serialized_metrics)
: 0);
android::util::stats_write(android::util::MEDIAMETRICS_MEDIADRM_REPORTED,
@@ -80,18 +80,18 @@
// widevineCDM
bool statsd_widevineCDM(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ 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;
- char *serialized_metrics = NULL;
+ char *serialized_metrics = nullptr;
(void) item->getCString("serialized_metrics", &serialized_metrics);
if (enabled_statsd) {
- android::util::BytesField bf_serialized(serialized_metrics ? serialized_metrics : NULL,
+ android::util::BytesField bf_serialized(serialized_metrics ? serialized_metrics : nullptr,
serialized_metrics ? strlen(serialized_metrics)
: 0);
android::util::stats_write(android::util::MEDIAMETRICS_DRM_WIDEVINE_REPORTED,
@@ -111,7 +111,7 @@
bool statsd_drmmanager(const mediametrics::Item *item)
{
using namespace std::string_literals;
- if (item == NULL) return false;
+ if (item == nullptr) return false;
if (!enabled_statsd) {
ALOGV("NOT sending: drmmanager data");
@@ -123,13 +123,13 @@
int64_t pkgVersionCode = item->getPkgVersionCode();
int64_t mediaApexVersion = 0;
- char *plugin_id = NULL;
+ char *plugin_id = nullptr;
(void) item->getCString("plugin_id", &plugin_id);
- char *description = NULL;
+ char *description = nullptr;
(void) item->getCString("description", &description);
int32_t method_id = -1;
(void) item->getInt32("method_id", &method_id);
- char *mime_types = NULL;
+ char *mime_types = nullptr;
(void) item->getCString("mime_types", &mime_types);
// Corresponds to the 13 APIs tracked in the MediametricsDrmManagerReported statsd proto
diff --git a/services/mediametrics/statsd_extractor.cpp b/services/mediametrics/statsd_extractor.cpp
index 8574358..3d5739f 100644
--- a/services/mediametrics/statsd_extractor.cpp
+++ b/services/mediametrics/statsd_extractor.cpp
@@ -39,7 +39,7 @@
bool statsd_extractor(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -91,4 +91,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/mediametrics/statsd_nuplayer.cpp b/services/mediametrics/statsd_nuplayer.cpp
index df7e59f..488bdcb 100644
--- a/services/mediametrics/statsd_nuplayer.cpp
+++ b/services/mediametrics/statsd_nuplayer.cpp
@@ -43,7 +43,7 @@
*/
bool statsd_nuplayer(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -167,4 +167,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/mediametrics/statsd_recorder.cpp b/services/mediametrics/statsd_recorder.cpp
index 4de1746..6d5fca0 100644
--- a/services/mediametrics/statsd_recorder.cpp
+++ b/services/mediametrics/statsd_recorder.cpp
@@ -39,7 +39,7 @@
bool statsd_recorder(const mediametrics::Item *item)
{
- if (item == NULL) return false;
+ if (item == nullptr) return false;
// these go into the statsd wrapper
const nsecs_t timestamp = MediaMetricsService::roundTime(item->getTimestamp());
@@ -186,4 +186,4 @@
return true;
}
-};
+} // namespace android
diff --git a/services/minijail/Android.bp b/services/minijail/Android.bp
index 5ea6d1e..b057968 100644
--- a/services/minijail/Android.bp
+++ b/services/minijail/Android.bp
@@ -18,6 +18,7 @@
name: "libavservices_minijail",
defaults: ["libavservices_minijail_defaults"],
vendor_available: true,
+ min_sdk_version: "29",
export_include_dirs: ["."],
}
diff --git a/services/oboeservice/AAudioService.cpp b/services/oboeservice/AAudioService.cpp
index ecbcb7e..82b12d6 100644
--- a/services/oboeservice/AAudioService.cpp
+++ b/services/oboeservice/AAudioService.cpp
@@ -23,7 +23,6 @@
#include <sstream>
#include <aaudio/AAudio.h>
-#include <mediautils/SchedulingPolicyService.h>
#include <mediautils/ServiceUtilities.h>
#include <utils/String16.h>
@@ -162,28 +161,6 @@
}
}
-// If a close request is pending then close the stream
-bool AAudioService::releaseStream(const sp<AAudioServiceStreamBase> &serviceStream) {
- bool closed = false;
- // decrementAndRemoveStreamByHandle() uses a lock so that if there are two simultaneous closes
- // then only one will get the pointer and do the close.
- sp<AAudioServiceStreamBase> foundStream = mStreamTracker.decrementAndRemoveStreamByHandle(
- serviceStream->getHandle());
- if (foundStream.get() != nullptr) {
- foundStream->close();
- pid_t pid = foundStream->getOwnerProcessId();
- AAudioClientTracker::getInstance().unregisterClientStream(pid, foundStream);
- closed = true;
- }
- return closed;
-}
-
-aaudio_result_t AAudioService::checkForPendingClose(
- const sp<AAudioServiceStreamBase> &serviceStream,
- aaudio_result_t defaultResult) {
- return releaseStream(serviceStream) ? AAUDIO_ERROR_INVALID_STATE : defaultResult;
-}
-
aaudio_result_t AAudioService::closeStream(aaudio_handle_t streamHandle) {
// Check permission and ownership first.
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
@@ -195,17 +172,20 @@
}
aaudio_result_t AAudioService::closeStream(sp<AAudioServiceStreamBase> serviceStream) {
+ // This is protected by a lock in AAudioClientTracker.
+ // It is safe to unregister the same stream twice.
pid_t pid = serviceStream->getOwnerProcessId();
AAudioClientTracker::getInstance().unregisterClientStream(pid, serviceStream);
+ // This is protected by a lock in mStreamTracker.
+ // It is safe to remove the same stream twice.
+ mStreamTracker.removeStreamByHandle(serviceStream->getHandle());
- serviceStream->markCloseNeeded();
- (void) releaseStream(serviceStream);
- return AAUDIO_OK;
+ return serviceStream->close();
}
sp<AAudioServiceStreamBase> AAudioService::convertHandleToServiceStream(
aaudio_handle_t streamHandle) {
- sp<AAudioServiceStreamBase> serviceStream = mStreamTracker.getStreamByHandleAndIncrement(
+ sp<AAudioServiceStreamBase> serviceStream = mStreamTracker.getStreamByHandle(
streamHandle);
if (serviceStream.get() != nullptr) {
// Only allow owner or the aaudio service to access the stream.
@@ -218,8 +198,6 @@
if (!allowed) {
ALOGE("AAudioService: calling uid %d cannot access stream 0x%08X owned by %d",
callingUserId, streamHandle, ownerUserId);
- // We incremented the reference count so we must check if it needs to be closed.
- checkForPendingClose(serviceStream, AAUDIO_OK);
serviceStream.clear();
}
}
@@ -234,96 +212,66 @@
ALOGE("getStreamDescription(), illegal stream handle = 0x%0x", streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
-
- aaudio_result_t result = serviceStream->getDescription(parcelable);
- // parcelable.dump();
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->getDescription(parcelable);
}
aaudio_result_t AAudioService::startStream(aaudio_handle_t streamHandle) {
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("startStream(), illegal stream handle = 0x%0x", streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
-
- aaudio_result_t result = serviceStream->start();
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->start();
}
aaudio_result_t AAudioService::pauseStream(aaudio_handle_t streamHandle) {
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("pauseStream(), illegal stream handle = 0x%0x", streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
- aaudio_result_t result = serviceStream->pause();
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->pause();
}
aaudio_result_t AAudioService::stopStream(aaudio_handle_t streamHandle) {
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("stopStream(), illegal stream handle = 0x%0x", streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
- aaudio_result_t result = serviceStream->stop();
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->stop();
}
aaudio_result_t AAudioService::flushStream(aaudio_handle_t streamHandle) {
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("flushStream(), illegal stream handle = 0x%0x", streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
- aaudio_result_t result = serviceStream->flush();
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->flush();
}
aaudio_result_t AAudioService::registerAudioThread(aaudio_handle_t streamHandle,
pid_t clientThreadId,
- int64_t periodNanoseconds) {
- aaudio_result_t result = AAUDIO_OK;
+ int64_t /* periodNanoseconds */) {
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("registerAudioThread(), illegal stream handle = 0x%0x", streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
- if (serviceStream->getRegisteredThread() != AAudioServiceStreamBase::ILLEGAL_THREAD_ID) {
- ALOGE("AAudioService::registerAudioThread(), thread already registered");
- result = AAUDIO_ERROR_INVALID_STATE;
- } else {
- const pid_t ownerPid = IPCThreadState::self()->getCallingPid(); // TODO review
- int32_t priority = isCallerInService()
- ? kRealTimeAudioPriorityService : kRealTimeAudioPriorityClient;
- serviceStream->setRegisteredThread(clientThreadId);
- int err = android::requestPriority(ownerPid, clientThreadId,
- priority, true /* isForApp */);
- if (err != 0) {
- ALOGE("AAudioService::registerAudioThread(%d) failed, errno = %d, priority = %d",
- clientThreadId, errno, priority);
- result = AAUDIO_ERROR_INTERNAL;
- }
- }
- return checkForPendingClose(serviceStream, result);
+ int32_t priority = isCallerInService()
+ ? kRealTimeAudioPriorityService : kRealTimeAudioPriorityClient;
+ return serviceStream->registerAudioThread(clientThreadId, priority);
}
aaudio_result_t AAudioService::unregisterAudioThread(aaudio_handle_t streamHandle,
pid_t clientThreadId) {
- aaudio_result_t result = AAUDIO_OK;
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("%s(), illegal stream handle = 0x%0x", __func__, streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
- if (serviceStream->getRegisteredThread() != clientThreadId) {
- ALOGE("%s(), wrong thread", __func__);
- result = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
- } else {
- serviceStream->setRegisteredThread(0);
- }
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->unregisterAudioThread(clientThreadId);
}
aaudio_result_t AAudioService::startClient(aaudio_handle_t streamHandle,
@@ -332,22 +280,20 @@
audio_port_handle_t *clientHandle) {
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("%s(), illegal stream handle = 0x%0x", __func__, streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
- aaudio_result_t result = serviceStream->startClient(client, attr, clientHandle);
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->startClient(client, attr, clientHandle);
}
aaudio_result_t AAudioService::stopClient(aaudio_handle_t streamHandle,
audio_port_handle_t portHandle) {
sp<AAudioServiceStreamBase> serviceStream = convertHandleToServiceStream(streamHandle);
if (serviceStream.get() == nullptr) {
- ALOGE("%s(), illegal stream handle = 0x%0x", __func__, streamHandle);
+ ALOGW("%s(), invalid streamHandle = 0x%0x", __func__, streamHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
- aaudio_result_t result = serviceStream->stopClient(portHandle);
- return checkForPendingClose(serviceStream, result);
+ return serviceStream->stopClient(portHandle);
}
// This is only called internally when AudioFlinger wants to tear down a stream.
@@ -355,12 +301,13 @@
aaudio_result_t AAudioService::disconnectStreamByPortHandle(audio_port_handle_t portHandle) {
ALOGD("%s(%d) called", __func__, portHandle);
sp<AAudioServiceStreamBase> serviceStream =
- mStreamTracker.findStreamByPortHandleAndIncrement(portHandle);
+ mStreamTracker.findStreamByPortHandle(portHandle);
if (serviceStream.get() == nullptr) {
ALOGE("%s(), could not find stream with portHandle = %d", __func__, portHandle);
return AAUDIO_ERROR_INVALID_HANDLE;
}
+ // This is protected by a lock and will just return if already stopped.
aaudio_result_t result = serviceStream->stop();
serviceStream->disconnect();
- return checkForPendingClose(serviceStream, result);
+ return result;
}
diff --git a/services/oboeservice/AAudioService.h b/services/oboeservice/AAudioService.h
index 6a2ac1f..caf48a5 100644
--- a/services/oboeservice/AAudioService.h
+++ b/services/oboeservice/AAudioService.h
@@ -114,11 +114,6 @@
sp<aaudio::AAudioServiceStreamBase> convertHandleToServiceStream(
aaudio::aaudio_handle_t streamHandle);
- bool releaseStream(const sp<aaudio::AAudioServiceStreamBase> &serviceStream);
-
- aaudio_result_t checkForPendingClose(const sp<aaudio::AAudioServiceStreamBase> &serviceStream,
- aaudio_result_t defaultResult);
-
android::AudioClient mAudioClient;
aaudio::AAudioStreamTracker mStreamTracker;
diff --git a/services/oboeservice/AAudioServiceEndpoint.cpp b/services/oboeservice/AAudioServiceEndpoint.cpp
index b09cbf4..15cbd82 100644
--- a/services/oboeservice/AAudioServiceEndpoint.cpp
+++ b/services/oboeservice/AAudioServiceEndpoint.cpp
@@ -90,14 +90,16 @@
std::vector<android::sp<AAudioServiceStreamBase>>
AAudioServiceEndpoint::disconnectRegisteredStreams() {
std::vector<android::sp<AAudioServiceStreamBase>> streamsDisconnected;
- std::lock_guard<std::mutex> lock(mLockStreams);
+ {
+ std::lock_guard<std::mutex> lock(mLockStreams);
+ mRegisteredStreams.swap(streamsDisconnected);
+ }
mConnected.store(false);
- for (const auto &stream : mRegisteredStreams) {
+ for (const auto &stream : streamsDisconnected) {
ALOGD("%s() - stop and disconnect port %d", __func__, stream->getPortHandle());
stream->stop();
stream->disconnect();
}
- mRegisteredStreams.swap(streamsDisconnected);
return streamsDisconnected;
}
diff --git a/services/oboeservice/AAudioServiceEndpointShared.cpp b/services/oboeservice/AAudioServiceEndpointShared.cpp
index 21253c8..dc21886 100644
--- a/services/oboeservice/AAudioServiceEndpointShared.cpp
+++ b/services/oboeservice/AAudioServiceEndpointShared.cpp
@@ -168,13 +168,11 @@
aaudio_result_t AAudioServiceEndpointShared::stopStream(sp<AAudioServiceStreamBase> sharedStream,
audio_port_handle_t clientHandle) {
- // Don't lock here because the disconnectRegisteredStreams also uses the lock.
-
// Ignore result.
(void) getStreamInternal()->stopClient(clientHandle);
if (--mRunningStreamCount == 0) { // atomic
- stopSharingThread();
+ stopSharingThread(); // the sharing thread locks mLockStreams
getStreamInternal()->requestStop();
}
return AAUDIO_OK;
diff --git a/services/oboeservice/AAudioServiceStreamBase.cpp b/services/oboeservice/AAudioServiceStreamBase.cpp
index 531bfa1..663dae2 100644
--- a/services/oboeservice/AAudioServiceStreamBase.cpp
+++ b/services/oboeservice/AAudioServiceStreamBase.cpp
@@ -24,6 +24,7 @@
#include <media/MediaMetricsItem.h>
#include <media/TypeConverter.h>
+#include <mediautils/SchedulingPolicyService.h>
#include "binding/IAAudioService.h"
#include "binding/AAudioServiceMessage.h"
@@ -169,11 +170,16 @@
}
aaudio_result_t AAudioServiceStreamBase::close() {
+ std::lock_guard<std::mutex> lock(mLock);
+ return close_l();
+}
+
+aaudio_result_t AAudioServiceStreamBase::close_l() {
if (getState() == AAUDIO_STREAM_STATE_CLOSED) {
return AAUDIO_OK;
}
- stop();
+ stop_l();
aaudio_result_t result = AAUDIO_OK;
sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
@@ -185,7 +191,7 @@
endpointManager.closeEndpoint(endpoint);
// AAudioService::closeStream() prevents two threads from closing at the same time.
- mServiceEndpoint.clear(); // endpoint will hold the pointer until this method returns.
+ mServiceEndpoint.clear(); // endpoint will hold the pointer after this method returns.
}
{
@@ -219,9 +225,18 @@
* An AAUDIO_SERVICE_EVENT_STARTED will be sent to the client when complete.
*/
aaudio_result_t AAudioServiceStreamBase::start() {
+ std::lock_guard<std::mutex> lock(mLock);
+
const int64_t beginNs = AudioClock::getNanoseconds();
aaudio_result_t result = AAUDIO_OK;
+ if (auto state = getState();
+ state == AAUDIO_STREAM_STATE_CLOSED || state == AAUDIO_STREAM_STATE_DISCONNECTED) {
+ ALOGW("%s() already CLOSED, returns INVALID_STATE, handle = %d",
+ __func__, getHandle());
+ return AAUDIO_ERROR_INVALID_STATE;
+ }
+
mediametrics::Defer defer([&] {
mediametrics::LogItem(mMetricsId)
.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_START)
@@ -231,7 +246,7 @@
.record(); });
if (isRunning()) {
- return AAUDIO_OK;
+ return result;
}
setFlowing(false);
@@ -254,16 +269,21 @@
return result;
error:
- disconnect();
+ disconnect_l();
return result;
}
aaudio_result_t AAudioServiceStreamBase::pause() {
- const int64_t beginNs = AudioClock::getNanoseconds();
+ std::lock_guard<std::mutex> lock(mLock);
+ return pause_l();
+}
+
+aaudio_result_t AAudioServiceStreamBase::pause_l() {
aaudio_result_t result = AAUDIO_OK;
if (!isRunning()) {
return result;
}
+ const int64_t beginNs = AudioClock::getNanoseconds();
mediametrics::Defer defer([&] {
mediametrics::LogItem(mMetricsId)
@@ -279,7 +299,7 @@
result = stopTimestampThread();
if (result != AAUDIO_OK) {
- disconnect();
+ disconnect_l();
return result;
}
@@ -292,7 +312,7 @@
result = endpoint->stopStream(this, mClientHandle);
if (result != AAUDIO_OK) {
ALOGE("%s() mServiceEndpoint returned %d, %s", __func__, result, getTypeText());
- disconnect(); // TODO should we return or pause Base first?
+ disconnect_l(); // TODO should we return or pause Base first?
}
sendServiceEvent(AAUDIO_SERVICE_EVENT_PAUSED);
@@ -301,11 +321,16 @@
}
aaudio_result_t AAudioServiceStreamBase::stop() {
- const int64_t beginNs = AudioClock::getNanoseconds();
+ std::lock_guard<std::mutex> lock(mLock);
+ return stop_l();
+}
+
+aaudio_result_t AAudioServiceStreamBase::stop_l() {
aaudio_result_t result = AAUDIO_OK;
if (!isRunning()) {
return result;
}
+ const int64_t beginNs = AudioClock::getNanoseconds();
mediametrics::Defer defer([&] {
mediametrics::LogItem(mMetricsId)
@@ -322,7 +347,7 @@
sendCurrentTimestamp(); // warning - this calls a virtual function
result = stopTimestampThread();
if (result != AAUDIO_OK) {
- disconnect();
+ disconnect_l();
return result;
}
@@ -336,7 +361,7 @@
result = endpoint->stopStream(this, mClientHandle);
if (result != AAUDIO_OK) {
ALOGE("%s() stopStream returned %d, %s", __func__, result, getTypeText());
- disconnect();
+ disconnect_l();
// TODO what to do with result here?
}
@@ -355,11 +380,12 @@
}
aaudio_result_t AAudioServiceStreamBase::flush() {
- const int64_t beginNs = AudioClock::getNanoseconds();
+ std::lock_guard<std::mutex> lock(mLock);
aaudio_result_t result = AAudio_isFlushAllowed(getState());
if (result != AAUDIO_OK) {
return result;
}
+ const int64_t beginNs = AudioClock::getNanoseconds();
mediametrics::Defer defer([&] {
mediametrics::LogItem(mMetricsId)
@@ -404,16 +430,66 @@
}
void AAudioServiceStreamBase::disconnect() {
- if (getState() != AAUDIO_STREAM_STATE_DISCONNECTED) {
+ std::lock_guard<std::mutex> lock(mLock);
+ disconnect_l();
+}
+
+void AAudioServiceStreamBase::disconnect_l() {
+ if (getState() != AAUDIO_STREAM_STATE_DISCONNECTED
+ && getState() != AAUDIO_STREAM_STATE_CLOSED) {
+
mediametrics::LogItem(mMetricsId)
.set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_DISCONNECT)
.set(AMEDIAMETRICS_PROP_STATE, AudioGlobal_convertStreamStateToText(getState()))
.record();
+
sendServiceEvent(AAUDIO_SERVICE_EVENT_DISCONNECTED);
setState(AAUDIO_STREAM_STATE_DISCONNECTED);
}
}
+aaudio_result_t AAudioServiceStreamBase::registerAudioThread(pid_t clientThreadId,
+ int priority) {
+ std::lock_guard<std::mutex> lock(mLock);
+ aaudio_result_t result = AAUDIO_OK;
+ if (getRegisteredThread() != AAudioServiceStreamBase::ILLEGAL_THREAD_ID) {
+ ALOGE("AAudioService::registerAudioThread(), thread already registered");
+ result = AAUDIO_ERROR_INVALID_STATE;
+ } else {
+ const pid_t ownerPid = IPCThreadState::self()->getCallingPid(); // TODO review
+ setRegisteredThread(clientThreadId);
+ int err = android::requestPriority(ownerPid, clientThreadId,
+ priority, true /* isForApp */);
+ if (err != 0) {
+ ALOGE("AAudioService::registerAudioThread(%d) failed, errno = %d, priority = %d",
+ clientThreadId, errno, priority);
+ result = AAUDIO_ERROR_INTERNAL;
+ }
+ }
+ return result;
+}
+
+aaudio_result_t AAudioServiceStreamBase::unregisterAudioThread(pid_t clientThreadId) {
+ std::lock_guard<std::mutex> lock(mLock);
+ aaudio_result_t result = AAUDIO_OK;
+ if (getRegisteredThread() != clientThreadId) {
+ ALOGE("%s(), wrong thread", __func__);
+ result = AAUDIO_ERROR_ILLEGAL_ARGUMENT;
+ } else {
+ setRegisteredThread(0);
+ }
+ return result;
+}
+
+void AAudioServiceStreamBase::setState(aaudio_stream_state_t state) {
+ // CLOSED is a final state.
+ if (mState != AAUDIO_STREAM_STATE_CLOSED) {
+ mState = state;
+ } else {
+ ALOGW_IF(mState != state, "%s(%d) when already CLOSED", __func__, state);
+ }
+}
+
aaudio_result_t AAudioServiceStreamBase::sendServiceEvent(aaudio_service_event_t event,
double dataDouble) {
AAudioServiceMessage command;
@@ -511,6 +587,7 @@
* used to communicate with the underlying HAL or Service.
*/
aaudio_result_t AAudioServiceStreamBase::getDescription(AudioEndpointParcelable &parcelable) {
+ std::lock_guard<std::mutex> lock(mLock);
{
std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
if (mUpMessageQueue == nullptr) {
diff --git a/services/oboeservice/AAudioServiceStreamBase.h b/services/oboeservice/AAudioServiceStreamBase.h
index 79dd738..94cc980 100644
--- a/services/oboeservice/AAudioServiceStreamBase.h
+++ b/services/oboeservice/AAudioServiceStreamBase.h
@@ -77,7 +77,7 @@
// because we had to wait until we generated the handle.
void logOpen(aaudio_handle_t streamHandle);
- virtual aaudio_result_t close();
+ aaudio_result_t close();
/**
* Start the flow of audio data.
@@ -85,7 +85,7 @@
* This is not guaranteed to be synchronous but it currently is.
* An AAUDIO_SERVICE_EVENT_STARTED will be sent to the client when complete.
*/
- virtual aaudio_result_t start();
+ aaudio_result_t start();
/**
* Stop the flow of data so that start() can resume without loss of data.
@@ -93,7 +93,7 @@
* This is not guaranteed to be synchronous but it currently is.
* An AAUDIO_SERVICE_EVENT_PAUSED will be sent to the client when complete.
*/
- virtual aaudio_result_t pause();
+ aaudio_result_t pause();
/**
* Stop the flow of data after the currently queued data has finished playing.
@@ -102,17 +102,14 @@
* An AAUDIO_SERVICE_EVENT_STOPPED will be sent to the client when complete.
*
*/
- virtual aaudio_result_t stop();
-
- aaudio_result_t stopTimestampThread();
+ aaudio_result_t stop();
/**
* Discard any data held by the underlying HAL or Service.
*
* An AAUDIO_SERVICE_EVENT_FLUSHED will be sent to the client when complete.
*/
- virtual aaudio_result_t flush();
-
+ aaudio_result_t flush();
virtual aaudio_result_t startClient(const android::AudioClient& client,
const audio_attributes_t *attr __unused,
@@ -126,29 +123,19 @@
return AAUDIO_ERROR_UNAVAILABLE;
}
+ aaudio_result_t registerAudioThread(pid_t clientThreadId, int priority);
+
+ aaudio_result_t unregisterAudioThread(pid_t clientThreadId);
+
bool isRunning() const {
return mState == AAUDIO_STREAM_STATE_STARTED;
}
- // -------------------------------------------------------------------
-
- /**
- * Send a message to the client with an int64_t data value.
- */
- aaudio_result_t sendServiceEvent(aaudio_service_event_t event,
- int64_t dataLong = 0);
- /**
- * Send a message to the client with an double data value.
- */
- aaudio_result_t sendServiceEvent(aaudio_service_event_t event,
- double dataDouble);
-
/**
* Fill in a parcelable description of stream.
*/
aaudio_result_t getDescription(AudioEndpointParcelable &parcelable);
-
void setRegisteredThread(pid_t pid) {
mRegisteredClientThread = pid;
}
@@ -262,9 +249,13 @@
aaudio_result_t open(const aaudio::AAudioStreamRequest &request,
aaudio_sharing_mode_t sharingMode);
- void setState(aaudio_stream_state_t state) {
- mState = state;
- }
+ // These must be called under mLock
+ virtual aaudio_result_t close_l();
+ virtual aaudio_result_t pause_l();
+ virtual aaudio_result_t stop_l();
+ void disconnect_l();
+
+ void setState(aaudio_stream_state_t state);
/**
* Device specific startup.
@@ -319,6 +310,19 @@
private:
+ aaudio_result_t stopTimestampThread();
+
+ /**
+ * Send a message to the client with an int64_t data value.
+ */
+ aaudio_result_t sendServiceEvent(aaudio_service_event_t event,
+ int64_t dataLong = 0);
+ /**
+ * Send a message to the client with a double data value.
+ */
+ aaudio_result_t sendServiceEvent(aaudio_service_event_t event,
+ double dataDouble);
+
/**
* @return true if the queue is getting full.
*/
@@ -336,6 +340,10 @@
// This indicate that a running stream should not be processed because of an error,
// for example a full message queue. Note that this atomic is unrelated to mCloseNeeded.
std::atomic<bool> mSuspended{false};
+
+ // Locking order is important.
+ // Always acquire mLock before acquiring AAudioServiceEndpoint::mLockStreams
+ std::mutex mLock; // Prevent start/stop/close etcetera from colliding
};
} /* namespace aaudio */
diff --git a/services/oboeservice/AAudioServiceStreamMMAP.cpp b/services/oboeservice/AAudioServiceStreamMMAP.cpp
index 639a0a8..54d7d06 100644
--- a/services/oboeservice/AAudioServiceStreamMMAP.cpp
+++ b/services/oboeservice/AAudioServiceStreamMMAP.cpp
@@ -92,11 +92,11 @@
}
// Stop the flow of data such that start() can resume with loss of data.
-aaudio_result_t AAudioServiceStreamMMAP::pause() {
+aaudio_result_t AAudioServiceStreamMMAP::pause_l() {
if (!isRunning()) {
return AAUDIO_OK;
}
- aaudio_result_t result = AAudioServiceStreamBase::pause();
+ aaudio_result_t result = AAudioServiceStreamBase::pause_l();
// TODO put before base::pause()?
if (!mInService) {
(void) stopClient(mClientHandle);
@@ -104,11 +104,11 @@
return result;
}
-aaudio_result_t AAudioServiceStreamMMAP::stop() {
+aaudio_result_t AAudioServiceStreamMMAP::stop_l() {
if (!isRunning()) {
return AAUDIO_OK;
}
- aaudio_result_t result = AAudioServiceStreamBase::stop();
+ aaudio_result_t result = AAudioServiceStreamBase::stop_l();
// TODO put before base::stop()?
if (!mInService) {
(void) stopClient(mClientHandle);
diff --git a/services/oboeservice/AAudioServiceStreamMMAP.h b/services/oboeservice/AAudioServiceStreamMMAP.h
index 9105469..5902613 100644
--- a/services/oboeservice/AAudioServiceStreamMMAP.h
+++ b/services/oboeservice/AAudioServiceStreamMMAP.h
@@ -52,16 +52,6 @@
aaudio_result_t open(const aaudio::AAudioStreamRequest &request) override;
- /**
- * Stop the flow of data so that start() can resume without loss of data.
- *
- * This is not guaranteed to be synchronous but it currently is.
- * An AAUDIO_SERVICE_EVENT_PAUSED will be sent to the client when complete.
- */
- aaudio_result_t pause() override;
-
- aaudio_result_t stop() override;
-
aaudio_result_t startClient(const android::AudioClient& client,
const audio_attributes_t *attr,
audio_port_handle_t *clientHandle) override;
@@ -72,6 +62,16 @@
protected:
+ /**
+ * Stop the flow of data so that start() can resume without loss of data.
+ *
+ * This is not guaranteed to be synchronous but it currently is.
+ * An AAUDIO_SERVICE_EVENT_PAUSED will be sent to the client when complete.
+ */
+ aaudio_result_t pause_l() override;
+
+ aaudio_result_t stop_l() override;
+
aaudio_result_t getAudioDataDescription(AudioEndpointParcelable &parcelable) override;
aaudio_result_t getFreeRunningPosition(int64_t *positionFrames, int64_t *timeNanos) override;
diff --git a/services/oboeservice/AAudioServiceStreamShared.cpp b/services/oboeservice/AAudioServiceStreamShared.cpp
index 2ca847a..01b1c2e 100644
--- a/services/oboeservice/AAudioServiceStreamShared.cpp
+++ b/services/oboeservice/AAudioServiceStreamShared.cpp
@@ -203,9 +203,8 @@
return result;
}
-
-aaudio_result_t AAudioServiceStreamShared::close() {
- aaudio_result_t result = AAudioServiceStreamBase::close();
+aaudio_result_t AAudioServiceStreamShared::close_l() {
+ aaudio_result_t result = AAudioServiceStreamBase::close_l();
{
std::lock_guard<std::mutex> lock(mAudioDataQueueLock);
diff --git a/services/oboeservice/AAudioServiceStreamShared.h b/services/oboeservice/AAudioServiceStreamShared.h
index 61769b5..abcb782 100644
--- a/services/oboeservice/AAudioServiceStreamShared.h
+++ b/services/oboeservice/AAudioServiceStreamShared.h
@@ -52,7 +52,7 @@
aaudio_result_t open(const aaudio::AAudioStreamRequest &request) override;
- aaudio_result_t close() override;
+ aaudio_result_t close_l() override;
/**
* This must be locked when calling getAudioDataFifoBuffer_l() and while
diff --git a/services/oboeservice/AAudioStreamTracker.cpp b/services/oboeservice/AAudioStreamTracker.cpp
index 3328159..8e66b94 100644
--- a/services/oboeservice/AAudioStreamTracker.cpp
+++ b/services/oboeservice/AAudioStreamTracker.cpp
@@ -30,32 +30,20 @@
using namespace android;
using namespace aaudio;
-sp<AAudioServiceStreamBase> AAudioStreamTracker::decrementAndRemoveStreamByHandle(
+int32_t AAudioStreamTracker::removeStreamByHandle(
aaudio_handle_t streamHandle) {
std::lock_guard<std::mutex> lock(mHandleLock);
- sp<AAudioServiceStreamBase> serviceStream;
- auto it = mStreamsByHandle.find(streamHandle);
- if (it != mStreamsByHandle.end()) {
- sp<AAudioServiceStreamBase> tempStream = it->second;
- // Does the caller need to close the stream?
- // The reference count should never be negative.
- // But it is safer to check for <= 0 than == 0.
- if ((tempStream->decrementServiceReferenceCount_l() <= 0) && tempStream->isCloseNeeded()) {
- serviceStream = tempStream; // Only return stream if ready to be closed.
- mStreamsByHandle.erase(it);
- }
- }
- return serviceStream;
+ auto count = mStreamsByHandle.erase(streamHandle);
+ return static_cast<int32_t>(count);
}
-sp<AAudioServiceStreamBase> AAudioStreamTracker::getStreamByHandleAndIncrement(
+sp<AAudioServiceStreamBase> AAudioStreamTracker::getStreamByHandle(
aaudio_handle_t streamHandle) {
std::lock_guard<std::mutex> lock(mHandleLock);
sp<AAudioServiceStreamBase> serviceStream;
auto it = mStreamsByHandle.find(streamHandle);
if (it != mStreamsByHandle.end()) {
serviceStream = it->second;
- serviceStream->incrementServiceReferenceCount_l();
}
return serviceStream;
}
@@ -63,7 +51,7 @@
// The port handle is only available when the stream is started.
// So we have to iterate over all the streams.
// Luckily this rarely happens.
-sp<AAudioServiceStreamBase> AAudioStreamTracker::findStreamByPortHandleAndIncrement(
+sp<AAudioServiceStreamBase> AAudioStreamTracker::findStreamByPortHandle(
audio_port_handle_t portHandle) {
std::lock_guard<std::mutex> lock(mHandleLock);
sp<AAudioServiceStreamBase> serviceStream;
@@ -72,7 +60,6 @@
auto candidate = it->second;
if (candidate->getPortHandle() == portHandle) {
serviceStream = candidate;
- serviceStream->incrementServiceReferenceCount_l();
break;
}
it++;
diff --git a/services/oboeservice/AAudioStreamTracker.h b/services/oboeservice/AAudioStreamTracker.h
index 57ec426..d1301a2 100644
--- a/services/oboeservice/AAudioStreamTracker.h
+++ b/services/oboeservice/AAudioStreamTracker.h
@@ -32,25 +32,20 @@
public:
/**
- * Find the stream associated with the handle.
- * Decrement its reference counter. If zero and the stream needs
- * to be closed then remove the stream and return a pointer to the stream.
- * Otherwise return null if it does not need to be closed.
+ * Remove any streams with the matching handle.
*
* @param streamHandle
- * @return strong pointer to the stream if it needs to be closed, or nullptr
+ * @return number of streams removed
*/
- android::sp<AAudioServiceStreamBase> decrementAndRemoveStreamByHandle(
- aaudio_handle_t streamHandle);
+ int32_t removeStreamByHandle(aaudio_handle_t streamHandle);
/**
* Look up a stream based on the handle.
- * Increment its service reference count if found.
*
* @param streamHandle
* @return strong pointer to the stream if found, or nullptr
*/
- android::sp<aaudio::AAudioServiceStreamBase> getStreamByHandleAndIncrement(
+ android::sp<aaudio::AAudioServiceStreamBase> getStreamByHandle(
aaudio_handle_t streamHandle);
/**
@@ -60,7 +55,7 @@
* @param portHandle
* @return strong pointer to the stream if found, or nullptr
*/
- android::sp<aaudio::AAudioServiceStreamBase> findStreamByPortHandleAndIncrement(
+ android::sp<aaudio::AAudioServiceStreamBase> findStreamByPortHandle(
audio_port_handle_t portHandle);
/**