Snap for 7239224 from fcfb426ee1dd350d003b7442cf362e85e5a4ff22 to sc-release (6083cd41) · Commits · e / os / android_frameworks_av

media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp

+86 −145

Original line number	Diff line number	Diff line
		@@ -42,6 +42,45 @@ static std::vector<std::tuple<std::string, std::string, std::string>> kCsdFlushT
		// Resource directory
		static std::string sResourceDir = "";

		struct CompToURL {
		std::string mime;
		std::string mURL;
		std::string info;
		};

		std::vector<CompToURL> kCompToURL = {
		{"mp4a-latm",
		"bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz.info"},
		{"mp4a-latm",
		"bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz_multi_frame.info"},
		{"audio/mpeg",
		"bbb_mp3_stereo_192kbps_48000hz.mp3", "bbb_mp3_stereo_192kbps_48000hz.info"},
		{"audio/mpeg",
		"bbb_mp3_stereo_192kbps_48000hz.mp3", "bbb_mp3_stereo_192kbps_48000hz_multi_frame.info"},
		{"3gpp",
		"sine_amrnb_1ch_12kbps_8000hz.amrnb", "sine_amrnb_1ch_12kbps_8000hz.info"},
		{"3gpp",
		"sine_amrnb_1ch_12kbps_8000hz.amrnb", "sine_amrnb_1ch_12kbps_8000hz_multi_frame.info"},
		{"amr-wb",
		"bbb_amrwb_1ch_14kbps_16000hz.amrwb", "bbb_amrwb_1ch_14kbps_16000hz.info"},
		{"amr-wb",
		"bbb_amrwb_1ch_14kbps_16000hz.amrwb", "bbb_amrwb_1ch_14kbps_16000hz_multi_frame.info"},
		{"vorbis",
		"bbb_vorbis_stereo_128kbps_48000hz.vorbis", "bbb_vorbis_stereo_128kbps_48000hz.info"},
		{"opus",
		"bbb_opus_stereo_128kbps_48000hz.opus", "bbb_opus_stereo_128kbps_48000hz.info"},
		{"g711-alaw",
		"bbb_g711alaw_1ch_8khz.raw", "bbb_g711alaw_1ch_8khz.info"},
		{"g711-mlaw",
		"bbb_g711mulaw_1ch_8khz.raw", "bbb_g711mulaw_1ch_8khz.info"},
		{"gsm",
		"bbb_gsm_1ch_8khz_13kbps.raw", "bbb_gsm_1ch_8khz_13kbps.info"},
		{"raw",
		"bbb_raw_1ch_8khz_s32le.raw", "bbb_raw_1ch_8khz_s32le.info"},
		{"flac",
		"bbb_flac_stereo_680kbps_48000hz.flac", "bbb_flac_stereo_680kbps_48000hz.info"},
		};

		class LinearBuffer : public C2Buffer {
		public:
		explicit LinearBuffer(const std::shared_ptr<C2LinearBlock>& block)
		@@ -76,33 +115,17 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test {
		mLinearPool = std::make_shared<C2PooledBlockPool>(mLinearAllocator, mBlockPoolId++);
		ASSERT_NE(mLinearPool, nullptr);

		mCompName = unknown_comp;
		struct StringToName {
		const char* Name;
		standardComp CompName;
		};
		const StringToName kStringToName[] = {
		{"xaac", xaac}, {"mp3", mp3}, {"amrnb", amrnb},
		{"amrwb", amrwb}, {"aac", aac}, {"vorbis", vorbis},
		{"opus", opus}, {"pcm", pcm}, {"g711.alaw", g711alaw},
		{"g711.mlaw", g711mlaw}, {"gsm", gsm}, {"raw", raw},
		{"flac", flac},
		};
		const size_t kNumStringToName = sizeof(kStringToName) / sizeof(kStringToName[0]);
		std::vector<std::unique_ptr<C2Param>> queried;
		mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE}, C2_DONT_BLOCK, &queried);
		ASSERT_GT(queried.size(), 0);

		mMime = ((C2PortMediaTypeSetting::input*)queried[0].get())->m.value;

		// Find the component type
		for (size_t i = 0; i < kNumStringToName; ++i) {
		if (strcasestr(mComponentName.c_str(), kStringToName[i].Name)) {
		mCompName = kStringToName[i].CompName;
		break;
		}
		}
		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";
		}

		@@ -119,6 +142,8 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test {

		virtual void validateTimestampList(int32_t* bitStreamInfo);

		void GetURLForComponent(char* mURL, char* info, size_t streamIndex = 0);

		struct outputMetaData {
		uint64_t timestampUs;
		uint32_t rangeLength;
		@@ -158,29 +183,12 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test {
		}
		}

		enum standardComp {
		xaac,
		mp3,
		amrnb,
		amrwb,
		aac,
		vorbis,
		opus,
		pcm,
		g711alaw,
		g711mlaw,
		gsm,
		raw,
		flac,
		unknown_comp,
		};

		std::string mMime;
		std::string mInstanceName;
		std::string mComponentName;
		bool mEos;
		bool mDisableTest;
		bool mTimestampDevTest;
		standardComp mCompName;

		int32_t mWorkResult;
		uint64_t mTimestampUs;
		@@ -217,7 +225,7 @@ class Codec2AudioDecHidlTest
		};

		void validateComponent(const std::shared_ptr<android::Codec2Client::Component>& component,
		Codec2AudioDecHidlTest::standardComp compName, bool& disableTest) {
		bool& disableTest) {
		// Validate its a C2 Component
		if (component->getName().find("c2") == std::string::npos) {
		ALOGE("Not a c2 component");
		@@ -244,13 +252,6 @@ void validateComponent(const std::shared_ptr<android::Codec2Client::Component>&
		return;
		}
		}

		// Validates component name
		if (compName == Codec2AudioDecHidlTest::unknown_comp) {
		ALOGE("Component InValid");
		disableTest = true;
		return;
		}
		ALOGV("Component Valid");
		}

		@@ -271,7 +272,7 @@ bool setupConfigParam(const std::shared_ptr<android::Codec2Client::Component>& c
		// parsing the header of elementary stream. Client needs to collect this
		// information and reconfigure
		void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component>& component,
		Codec2AudioDecHidlTest::standardComp compName, int32_t* bitStreamInfo) {
		std::string mime, int32_t* bitStreamInfo) {
		// query nSampleRate and nChannels
		std::initializer_list<C2Param::Index> indices{
		C2StreamSampleRateInfo::output::PARAM_TYPE,
		@@ -288,90 +289,30 @@ void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component>
		C2Param* param = inParams[i].get();
		bitStreamInfo[i] = (int32_t)((uint8_t*)param + offset);
		}
		switch (compName) {
		case Codec2AudioDecHidlTest::amrnb: {
		if (mime.find("3gpp") != std::string::npos) {
		ASSERT_EQ(bitStreamInfo[0], 8000);
		ASSERT_EQ(bitStreamInfo[1], 1);
		break;
		}
		case Codec2AudioDecHidlTest::amrwb: {
		} else if (mime.find("amr-wb") != std::string::npos) {
		ASSERT_EQ(bitStreamInfo[0], 16000);
		ASSERT_EQ(bitStreamInfo[1], 1);
		break;
		}
		case Codec2AudioDecHidlTest::gsm: {
		} else if (mime.find("gsm") != std::string::npos) {
		ASSERT_EQ(bitStreamInfo[0], 8000);
		break;
		}
		default:
		break;
		}
		}
		}

		// number of elementary streams per component
		#define STREAM_COUNT 2

		// LookUpTable of clips and metadata for component testing
		void GetURLForComponent(Codec2AudioDecHidlTest::standardComp comp, char* mURL, char* info,
		size_t streamIndex = 0) {
		struct CompToURL {
		Codec2AudioDecHidlTest::standardComp comp;
		const char mURL[STREAM_COUNT][512];
		const char info[STREAM_COUNT][512];
		};
		ASSERT_TRUE(streamIndex < STREAM_COUNT);

		static const CompToURL kCompToURL[] = {
		{Codec2AudioDecHidlTest::standardComp::xaac,
		{"bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz.aac"},
		{"bbb_aac_stereo_128kbps_48000hz.info",
		"bbb_aac_stereo_128kbps_48000hz_multi_frame.info"}},
		{Codec2AudioDecHidlTest::standardComp::mp3,
		{"bbb_mp3_stereo_192kbps_48000hz.mp3", "bbb_mp3_stereo_192kbps_48000hz.mp3"},
		{"bbb_mp3_stereo_192kbps_48000hz.info",
		"bbb_mp3_stereo_192kbps_48000hz_multi_frame.info"}},
		{Codec2AudioDecHidlTest::standardComp::aac,
		{"bbb_aac_stereo_128kbps_48000hz.aac", "bbb_aac_stereo_128kbps_48000hz.aac"},
		{"bbb_aac_stereo_128kbps_48000hz.info",
		"bbb_aac_stereo_128kbps_48000hz_multi_frame.info"}},
		{Codec2AudioDecHidlTest::standardComp::amrnb,
		{"sine_amrnb_1ch_12kbps_8000hz.amrnb", "sine_amrnb_1ch_12kbps_8000hz.amrnb"},
		{"sine_amrnb_1ch_12kbps_8000hz.info",
		"sine_amrnb_1ch_12kbps_8000hz_multi_frame.info"}},
		{Codec2AudioDecHidlTest::standardComp::amrwb,
		{"bbb_amrwb_1ch_14kbps_16000hz.amrwb", "bbb_amrwb_1ch_14kbps_16000hz.amrwb"},
		{"bbb_amrwb_1ch_14kbps_16000hz.info",
		"bbb_amrwb_1ch_14kbps_16000hz_multi_frame.info"}},
		{Codec2AudioDecHidlTest::standardComp::vorbis,
		{"bbb_vorbis_stereo_128kbps_48000hz.vorbis", ""},
		{"bbb_vorbis_stereo_128kbps_48000hz.info", ""}},
		{Codec2AudioDecHidlTest::standardComp::opus,
		{"bbb_opus_stereo_128kbps_48000hz.opus", ""},
		{"bbb_opus_stereo_128kbps_48000hz.info", ""}},
		{Codec2AudioDecHidlTest::standardComp::g711alaw,
		{"bbb_g711alaw_1ch_8khz.raw", ""},
		{"bbb_g711alaw_1ch_8khz.info", ""}},
		{Codec2AudioDecHidlTest::standardComp::g711mlaw,
		{"bbb_g711mulaw_1ch_8khz.raw", ""},
		{"bbb_g711mulaw_1ch_8khz.info", ""}},
		{Codec2AudioDecHidlTest::standardComp::gsm,
		{"bbb_gsm_1ch_8khz_13kbps.raw", ""},
		{"bbb_gsm_1ch_8khz_13kbps.info", ""}},
		{Codec2AudioDecHidlTest::standardComp::raw,
		{"bbb_raw_1ch_8khz_s32le.raw", ""},
		{"bbb_raw_1ch_8khz_s32le.info", ""}},
		{Codec2AudioDecHidlTest::standardComp::flac,
		{"bbb_flac_stereo_680kbps_48000hz.flac", ""},
		{"bbb_flac_stereo_680kbps_48000hz.info", ""}},
		};

		for (size_t i = 0; i < sizeof(kCompToURL) / sizeof(kCompToURL[0]); ++i) {
		if (kCompToURL[i].comp == comp) {
		strcat(mURL, kCompToURL[i].mURL[streamIndex]);
		strcat(info, kCompToURL[i].info[streamIndex]);
		void Codec2AudioDecHidlTestBase::GetURLForComponent(char* mURL, char* info, size_t streamIndex) {
		int streamCount = 0;
		for (size_t i = 0; i < kCompToURL.size(); ++i) {
		if (mMime.find(kCompToURL[i].mime) != std::string::npos) {
		if (streamCount == streamIndex) {
		strcat(mURL, kCompToURL[i].mURL.c_str());
		strcat(info, kCompToURL[i].info.c_str());
		return;
		}
		streamCount++;
		}
		}
		}

		@@ -461,7 +402,7 @@ void decodeNFrames(const std::shared_ptr<android::Codec2Client::Component>& comp
		void Codec2AudioDecHidlTestBase::validateTimestampList(int32_t* bitStreamInfo) {
		uint32_t samplesReceived = 0;
		// Update SampleRate and ChannelCount
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
		int32_t nSampleRate = bitStreamInfo[0];
		int32_t nChannels = bitStreamInfo[1];
		std::list<uint64_t>::iterator itIn = mTimestampUslist.begin();
		@@ -486,7 +427,7 @@ void Codec2AudioDecHidlTestBase::validateTimestampList(int32_t* bitStreamInfo) {
		TEST_P(Codec2AudioDecHidlTest, validateCompName) {
		if (mDisableTest) GTEST_SKIP() << "Test is disabled";
		ALOGV("Checks if the given component is a valid audio component");
		validateComponent(mComponent, mCompName, mDisableTest);
		validateComponent(mComponent, mDisableTest);
		ASSERT_EQ(mDisableTest, false);
		}

		@@ -495,7 +436,7 @@ TEST_P(Codec2AudioDecHidlTest, configComp) {
		if (mDisableTest) GTEST_SKIP() << "Test is disabled";
		ASSERT_EQ(mComponent->start(), C2_OK);
		int32_t bitStreamInfo[2] = {0};
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
		setupConfigParam(mComponent, bitStreamInfo);
		ASSERT_EQ(mComponent->stop(), C2_OK);
		}
		@@ -523,7 +464,7 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) {

		strcpy(mURL, sResourceDir.c_str());
		strcpy(info, sResourceDir.c_str());
		GetURLForComponent(mCompName, mURL, info, streamIndex);
		GetURLForComponent(mURL, info, streamIndex);
		if (!strcmp(mURL, sResourceDir.c_str())) {
		ALOGV("EMPTY INPUT sResourceDir.c_str() %s mURL %s ", sResourceDir.c_str(), mURL);
		return;
		@@ -536,11 +477,11 @@ TEST_P(Codec2AudioDecDecodeTest, DecodeTest) {
		mFramesReceived = 0;
		mTimestampUs = 0;
		int32_t bitStreamInfo[2] = {0};
		if (mCompName == raw) {
		if (mMime.find("raw") != std::string::npos) {
		bitStreamInfo[0] = 8000;
		bitStreamInfo[1] = 1;
		} else {
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
		}
		if (!setupConfigParam(mComponent, bitStreamInfo)) {
		std::cout << "[ WARN ] Test Skipped \n";
		@@ -591,17 +532,17 @@ TEST_P(Codec2AudioDecHidlTest, ThumbnailTest) {

		strcpy(mURL, sResourceDir.c_str());
		strcpy(info, sResourceDir.c_str());
		GetURLForComponent(mCompName, mURL, info);
		GetURLForComponent(mURL, info);

		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) {
		if (mMime.find("raw") != std::string::npos) {
		bitStreamInfo[0] = 8000;
		bitStreamInfo[1] = 1;
		} else {
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
		}
		if (!setupConfigParam(mComponent, bitStreamInfo)) {
		std::cout << "[ WARN ] Test Skipped \n";
		@@ -683,17 +624,17 @@ TEST_P(Codec2AudioDecHidlTest, FlushTest) {

		strcpy(mURL, sResourceDir.c_str());
		strcpy(info, sResourceDir.c_str());
		GetURLForComponent(mCompName, mURL, info);
		GetURLForComponent(mURL, info);

		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) {
		if (mMime.find("raw") != std::string::npos) {
		bitStreamInfo[0] = 8000;
		bitStreamInfo[1] = 1;
		} else {
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
		}
		if (!setupConfigParam(mComponent, bitStreamInfo)) {
		std::cout << "[ WARN ] Test Skipped \n";
		@@ -768,7 +709,7 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) {

		strcpy(mURL, sResourceDir.c_str());
		strcpy(info, sResourceDir.c_str());
		GetURLForComponent(mCompName, mURL, info);
		GetURLForComponent(mURL, info);

		eleInfo.open(info);
		ASSERT_EQ(eleInfo.is_open(), true) << mURL << " - file not found";
		@@ -798,11 +739,11 @@ TEST_P(Codec2AudioDecHidlTest, DecodeTestEmptyBuffersInserted) {
		}
		eleInfo.close();
		int32_t bitStreamInfo[2] = {0};
		if (mCompName == raw) {
		if (mMime.find("raw") != std::string::npos) {
		bitStreamInfo[0] = 8000;
		bitStreamInfo[1] = 1;
		} else {
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
		}
		if (!setupConfigParam(mComponent, bitStreamInfo)) {
		std::cout << "[ WARN ] Test Skipped \n";
		@@ -853,7 +794,7 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) {

		strcpy(mURL, sResourceDir.c_str());
		strcpy(info, sResourceDir.c_str());
		GetURLForComponent(mCompName, mURL, info);
		GetURLForComponent(mURL, info);
		if (!strcmp(mURL, sResourceDir.c_str())) {
		ALOGV("EMPTY INPUT sResourceDir.c_str() %s mURL %s ", sResourceDir.c_str(), mURL);
		return;
		@@ -864,11 +805,11 @@ TEST_P(Codec2AudioDecCsdInputTests, CSDFlushTest) {
		ASSERT_GE(numCsds, 0) << "Error in parsing input info file";

		int32_t bitStreamInfo[2] = {0};
		if (mCompName == raw) {
		if (mMime.find("raw") != std::string::npos) {
		bitStreamInfo[0] = 8000;
		bitStreamInfo[1] = 1;
		} else {
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mCompName, bitStreamInfo));
		ASSERT_NO_FATAL_FAILURE(getInputChannelInfo(mComponent, mMime, bitStreamInfo));
		}
		if (!setupConfigParam(mComponent, bitStreamInfo)) {
		std::cout << "[ WARN ] Test Skipped \n";

media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp

+82 −109

File changed.

Preview size limit exceeded, changes collapsed.

media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp

+2 −1

Original line number	Diff line number	Diff line
		@@ -110,7 +110,8 @@ class Codec2VideoEncHidlTestBase : public ::testing::Test {

		C2SecureModeTuning secureModeTuning{};
		mComponent->query({&secureModeTuning}, {}, C2_MAY_BLOCK, nullptr);
		if (secureModeTuning.value == C2Config::SM_READ_PROTECTED) {
		if (secureModeTuning.value == C2Config::SM_READ_PROTECTED \|\|
		secureModeTuning.value == C2Config::SM_READ_PROTECTED_WITH_ENCRYPTED) {
		mDisableTest = true;
		}

media/codec2/vndk/C2AllocatorIon.cpp

+7 −32

Original line number	Diff line number	Diff line
		@@ -30,15 +30,10 @@
		#include <C2ErrnoUtils.h>
		#include <C2HandleIonInternal.h>

		#include <android-base/properties.h>

		namespace android {

		namespace {
		constexpr size_t USAGE_LRU_CACHE_SIZE = 1024;

		// max padding after ion/dmabuf allocations in bytes
		constexpr uint32_t MAX_PADDING = 0x8000; // 32KB
		}

		/* size_t <=> int(lo), int(hi) conversions */
		@@ -381,34 +376,14 @@ C2AllocationIon::Impl *C2AllocationIon::Impl::Alloc(int ionFd, size_t size, size
		unsigned heapMask, unsigned flags, C2Allocator::id_t id) {
		int bufferFd = -1;
		ion_user_handle_t buffer = -1;
		// NOTE: read this property directly from the property as this code has to run on
		// Android Q, but the sysprop was only introduced in Android S.
		static size_t sPadding =
		base::GetUintProperty("media.c2.dmabuf.padding", (uint32_t)0, MAX_PADDING);
		if (sPadding > SIZE_MAX - size) {
		ALOGD("ion_alloc: size %#zx cannot accommodate padding %#zx", size, sPadding);
		// use ImplV2 as there is no allocation anyways
		return new ImplV2(ionFd, size, -1, id, -ENOMEM);
		}

		size_t allocSize = size + sPadding;
		if (align) {
		if (align - 1 > SIZE_MAX - allocSize) {
		ALOGD("ion_alloc: size %#zx cannot accommodate padding %#zx and alignment %#zx",
		size, sPadding, align);
		// use ImplV2 as there is no allocation anyways
		return new ImplV2(ionFd, size, -1, id, -ENOMEM);
		}
		allocSize += align - 1;
		allocSize &= ~(align - 1);
		}
		size_t alignedSize = align == 0 ? size : (size + align - 1) & ~(align - 1);
		int ret;

		if (ion_is_legacy(ionFd)) {
		ret = ion_alloc(ionFd, allocSize, align, heapMask, flags, &buffer);
		ret = ion_alloc(ionFd, alignedSize, align, heapMask, flags, &buffer);
		ALOGV("ion_alloc(ionFd = %d, size = %zu, align = %zu, prot = %d, flags = %d) "
		"returned (%d) ; buffer = %d",
		ionFd, allocSize, align, heapMask, flags, ret, buffer);
		ionFd, alignedSize, align, heapMask, flags, ret, buffer);
		if (ret == 0) {
		// get buffer fd for native handle constructor
		ret = ion_share(ionFd, buffer, &bufferFd);
		@@ -417,15 +392,15 @@ C2AllocationIon::Impl *C2AllocationIon::Impl::Alloc(int ionFd, size_t size, size
		buffer = -1;
		}
		}
		return new Impl(ionFd, size, bufferFd, buffer, id, ret);
		return new Impl(ionFd, alignedSize, bufferFd, buffer, id, ret);

		} else {
		ret = ion_alloc_fd(ionFd, allocSize, align, heapMask, flags, &bufferFd);
		ret = ion_alloc_fd(ionFd, alignedSize, align, heapMask, flags, &bufferFd);
		ALOGV("ion_alloc_fd(ionFd = %d, size = %zu, align = %zu, prot = %d, flags = %d) "
		"returned (%d) ; bufferFd = %d",
		ionFd, allocSize, align, heapMask, flags, ret, bufferFd);
		ionFd, alignedSize, align, heapMask, flags, ret, bufferFd);

		return new ImplV2(ionFd, size, bufferFd, id, ret);
		return new ImplV2(ionFd, alignedSize, bufferFd, id, ret);
		}
		}

media/codec2/vndk/C2DmaBufAllocator.cpp

+5 −22

Original line number	Diff line number	Diff line
		@@ -16,13 +16,11 @@

		//#define LOG_NDEBUG 0
		#define LOG_TAG "C2DmaBufAllocator"

		#include <BufferAllocator/BufferAllocator.h>
		#include <C2Buffer.h>
		#include <C2Debug.h>
		#include <C2DmaBufAllocator.h>
		#include <C2ErrnoUtils.h>

		#include <linux/ion.h>
		#include <sys/mman.h>
		#include <unistd.h> // getpagesize, size_t, close, dup
		@@ -30,15 +28,14 @@

		#include <list>

		#ifdef __ANDROID_APEX__
		#include <android-base/properties.h>
		#endif

		namespace android {

		namespace {
		constexpr size_t USAGE_LRU_CACHE_SIZE = 1024;

		// max padding after ion/dmabuf allocations in bytes
		constexpr uint32_t MAX_PADDING = 0x8000; // 32KB
		}

		/* =========================== BUFFER HANDLE =========================== */
		@@ -252,23 +249,9 @@ C2DmaBufAllocation::C2DmaBufAllocation(BufferAllocator& alloc, size_t size, C2St
		int bufferFd = -1;
		int ret = 0;

		// NOTE: read this property directly from the property as this code has to run on
		// Android Q, but the sysprop was only introduced in Android S.
		static size_t sPadding =
		base::GetUintProperty("media.c2.dmabuf.padding", (uint32_t)0, MAX_PADDING);
		if (sPadding > SIZE_MAX - size) {
		// size would overflow
		ALOGD("dmabuf_alloc: size #%zx cannot accommodate padding #%zx", size, sPadding);
		ret = -ENOMEM;
		} else {
		size_t allocSize = size + sPadding;
		bufferFd = alloc.Alloc(heap_name, allocSize, flags);
		if (bufferFd < 0) {
		ret = bufferFd;
		}
		}
		bufferFd = alloc.Alloc(heap_name, size, flags);
		if (bufferFd < 0) ret = bufferFd;

		// this may be a non-working handle if bufferFd is negative
		mHandle = C2HandleBuf(bufferFd, size);
		mId = id;
		mInit = c2_status_t(c2_map_errno<ENOMEM, EACCES, EINVAL>(ret));