Merge changes Iee37bb97,If7c549b8 am: 83ea817a8c (edd8ea3f) · Commits · e / os / android_hardware_interfaces

graphics/common/aidl/android/hardware/graphics/common/StandardMetadataType.aidl

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -22,9 +22,9 @@ package android.hardware.graphics.common;
	* This is an enum that defines the common types of gralloc 4 buffer metadata. The comments for		* This is an enum that defines the common types of gralloc 4 buffer metadata. The comments for
	* each enum include a description of the metadata that is associated with the type.		* each enum include a description of the metadata that is associated with the type.
	*		*
	* IMapper@4.x must support getting the following standard buffer metadata types, with the exception		* IMapper@4.x & later must support getting the following standard buffer metadata types, with the
	* of SMPTE 2094-10 metadata. IMapper@4.x may support setting these standard buffer metadata types		* exception of SMPTE 2094-10 and SMPTE 2094-40 metadata. IMapper@4.x & later may support setting
	* as well.		* these standard buffer metadata types as well.
	*		*
	* When encoding these StandardMetadataTypes into a byte stream, the associated MetadataType is		* When encoding these StandardMetadataTypes into a byte stream, the associated MetadataType is
	* is first encoded followed by the StandardMetadataType value. The MetadataType is encoded by		* is first encoded followed by the StandardMetadataType value. The MetadataType is encoded by

graphics/mapper/stable-c/Android.bp

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -61,6 +61,10 @@ cc_test {
	srcs: [		srcs: [
	"implutils/impltests.cpp",		"implutils/impltests.cpp",
	],		],
			shared_libs: [
			"libgralloctypes",
			"libhidlbase",
			],
	visibility: [":__subpackages__"],		visibility: [":__subpackages__"],
	cpp_std: "experimental",		cpp_std: "experimental",
	}		}

graphics/mapper/stable-c/implutils/impltests.cpp

+290 −70

Original line number	Original line	Diff line number	Diff line
	@@ -18,27 +18,61 @@

	#include <android/hardware/graphics/mapper/utils/IMapperMetadataTypes.h>		#include <android/hardware/graphics/mapper/utils/IMapperMetadataTypes.h>
	#include <android/hardware/graphics/mapper/utils/IMapperProvider.h>		#include <android/hardware/graphics/mapper/utils/IMapperProvider.h>
			#include <drm/drm_fourcc.h>
			#include <gralloctypes/Gralloc4.h>
			#include <span>
	#include <vector>		#include <vector>

			using namespace ::android;
	using namespace ::android::hardware::graphics::mapper;		using namespace ::android::hardware::graphics::mapper;
	using namespace ::aidl::android::hardware::graphics::common;		using namespace ::aidl::android::hardware::graphics::common;
			namespace gralloc4 = ::android::gralloc4;
			using ::android::hardware::hidl_vec;

	// These tests are primarily interested in hitting all the different types that can be		// These tests are primarily interested in hitting all the different types that can be
	// serialized/deserialized than in exhaustively testing all the StandardMetadataTypes.		// serialized/deserialized than in exhaustively testing all the StandardMetadataTypes.
	// Exhaustive testing of the actual metadata types is relegated for IMapper's VTS suite		// Exhaustive testing of the actual metadata types is relegated for IMapper's VTS suite
	// where meaning & correctness of values are more narrowly defined (eg, read-only values)		// where meaning & correctness of values are more narrowly defined (eg, read-only values)

			static constexpr auto HeaderSize = 69;

			static std::span<uint8_t> SkipHeader(std::vector<uint8_t>& buffer) {
			return std::span<uint8_t>(buffer).subspan(HeaderSize);
			}

			static std::vector<PlaneLayout> fakePlaneLayouts() {
			PlaneLayout myPlaneLayout;
			myPlaneLayout.offsetInBytes = 10;
			myPlaneLayout.sampleIncrementInBits = 11;
			myPlaneLayout.strideInBytes = 12;
			myPlaneLayout.widthInSamples = 13;
			myPlaneLayout.heightInSamples = 14;
			myPlaneLayout.totalSizeInBytes = 15;
			myPlaneLayout.horizontalSubsampling = 16;
			myPlaneLayout.verticalSubsampling = 17;

			myPlaneLayout.components.resize(3);
			for (int i = 0; i < myPlaneLayout.components.size(); i++) {
			auto& it = myPlaneLayout.components[i];
			it.type = ExtendableType{"Plane ID", 40 + i};
			it.offsetInBits = 20 + i;
			it.sizeInBits = 30 + i;
			}

			return std::vector<PlaneLayout>{myPlaneLayout, PlaneLayout{}};
			}

	TEST(Metadata, setGetBufferId) {		TEST(Metadata, setGetBufferId) {
	using BufferId = StandardMetadata<StandardMetadataType::BUFFER_ID>::value;		using BufferId = StandardMetadata<StandardMetadataType::BUFFER_ID>::value;

	std::vector<char> buffer;		std::vector<uint8_t> buffer(10000, 0);
	buffer.resize(12, 0);		int64_t* payload = reinterpret_cast<int64_t*>(SkipHeader(buffer).data());
	reinterpret_cast<int64_t>(buffer.data()) = 42;		*payload = 42;

	EXPECT_EQ(8, BufferId::encode(18, buffer.data(), 0));		EXPECT_EQ(8 + HeaderSize, BufferId::encode(18, buffer.data(), 0));
	EXPECT_EQ(42, reinterpret_cast<int64_t>(buffer.data()));		EXPECT_EQ(42, *payload);
	EXPECT_EQ(8, BufferId::encode(18, buffer.data(), buffer.size()));		EXPECT_EQ(8 + HeaderSize, BufferId::encode(18, buffer.data(), buffer.size()));
	EXPECT_EQ(18, reinterpret_cast<int64_t>(buffer.data()));		EXPECT_EQ(18, *payload);
	EXPECT_FALSE(BufferId::decode(buffer.data(), 0));		EXPECT_FALSE(BufferId::decode(buffer.data(), 0));
	auto read = BufferId::decode(buffer.data(), buffer.size());		auto read = BufferId::decode(buffer.data(), buffer.size());
	EXPECT_TRUE(read.has_value());		EXPECT_TRUE(read.has_value());
	@@ -48,13 +82,14 @@ TEST(Metadata, setGetBufferId) {
	TEST(Metadata, setGetDataspace) {		TEST(Metadata, setGetDataspace) {
	using DataspaceValue = StandardMetadata<StandardMetadataType::DATASPACE>::value;		using DataspaceValue = StandardMetadata<StandardMetadataType::DATASPACE>::value;
	using intType = std::underlying_type_t<Dataspace>;		using intType = std::underlying_type_t<Dataspace>;
	std::vector<char> buffer;		std::vector<uint8_t> buffer(10000, 0);
	buffer.resize(12, 0);		auto data = SkipHeader(buffer);

	EXPECT_EQ(4, DataspaceValue::encode(Dataspace::BT2020, buffer.data(), 0));		EXPECT_EQ(4 + HeaderSize, DataspaceValue::encode(Dataspace::BT2020, buffer.data(), 0));
	EXPECT_EQ(0, reinterpret_cast<intType>(buffer.data()));		EXPECT_EQ(0, reinterpret_cast<intType>(data.data()));
	EXPECT_EQ(4, DataspaceValue::encode(Dataspace::BT2020, buffer.data(), buffer.size()));		EXPECT_EQ(4 + HeaderSize,
	EXPECT_EQ(static_cast<intType>(Dataspace::BT2020), reinterpret_cast<intType>(buffer.data()));		DataspaceValue::encode(Dataspace::BT2020, buffer.data(), buffer.size()));
			EXPECT_EQ(static_cast<intType>(Dataspace::BT2020), reinterpret_cast<intType>(data.data()));
	EXPECT_FALSE(DataspaceValue::decode(buffer.data(), 0));		EXPECT_FALSE(DataspaceValue::decode(buffer.data(), 0));
	auto read = DataspaceValue::decode(buffer.data(), buffer.size());		auto read = DataspaceValue::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	@@ -64,14 +99,12 @@ TEST(Metadata, setGetDataspace) {
	TEST(Metadata, setGetValidName) {		TEST(Metadata, setGetValidName) {
	using NameValue = StandardMetadata<StandardMetadataType::NAME>::value;		using NameValue = StandardMetadata<StandardMetadataType::NAME>::value;

	std::vector<char> buffer;		std::vector<uint8_t> buffer(10000, 'a');
	buffer.resize(100, 'a');
	buffer[buffer.size() - 1] = '\0';

	// len("Hello") + sizeof(int64)		// len("Hello") + sizeof(int64)
	constexpr int expectedSize = 5 + sizeof(int64_t);		constexpr int expectedSize = 5 + sizeof(int64_t) + HeaderSize;
	EXPECT_EQ(expectedSize, NameValue::encode("Hello", buffer.data(), buffer.size()));		EXPECT_EQ(expectedSize, NameValue::encode("Hello", buffer.data(), buffer.size()));
	EXPECT_EQ(5, reinterpret_cast<int64_t>(buffer.data()));		EXPECT_EQ(5, reinterpret_cast<int64_t>(SkipHeader(buffer).data()));
	// Verify didn't write past the end of the desired size		// Verify didn't write past the end of the desired size
	EXPECT_EQ('a', buffer[expectedSize]);		EXPECT_EQ('a', buffer[expectedSize]);

	@@ -84,18 +117,15 @@ TEST(Metadata, setGetValidName) {
	TEST(Metadata, setGetInvalidName) {		TEST(Metadata, setGetInvalidName) {
	using NameValue = StandardMetadata<StandardMetadataType::NAME>::value;		using NameValue = StandardMetadata<StandardMetadataType::NAME>::value;

	std::vector<char> buffer;		std::vector<uint8_t> buffer;
	buffer.resize(12, 'a');		buffer.resize(12 + HeaderSize, 'a');
	buffer[buffer.size() - 1] = '\0';		buffer[buffer.size() - 1] = '\0';

	// len("This is a long string") + sizeof(int64)		// len("This is a long string") + sizeof(int64)
	constexpr int expectedSize = 21 + sizeof(int64_t);		constexpr int expectedSize = 21 + sizeof(int64_t) + HeaderSize;
	EXPECT_EQ(expectedSize,		EXPECT_EQ(expectedSize,
	NameValue::encode("This is a long string", buffer.data(), buffer.size()));		NameValue::encode("This is a long string", buffer.data(), buffer.size()));
	EXPECT_EQ(21, reinterpret_cast<int64_t>(buffer.data()));		EXPECT_EQ(21, reinterpret_cast<int64_t>(SkipHeader(buffer).data()));
	// Verify didn't write the too-long string
	EXPECT_EQ('a', buffer[9]);
	EXPECT_EQ('\0', buffer[buffer.size() - 1]);

	auto readValue = NameValue::decode(buffer.data(), buffer.size());		auto readValue = NameValue::decode(buffer.data(), buffer.size());
	EXPECT_FALSE(readValue.has_value());		EXPECT_FALSE(readValue.has_value());
	@@ -105,7 +135,7 @@ TEST(Metadata, setGetInvalidName) {

	TEST(Metadata, wouldOverflowName) {		TEST(Metadata, wouldOverflowName) {
	using NameValue = StandardMetadata<StandardMetadataType::NAME>::value;		using NameValue = StandardMetadata<StandardMetadataType::NAME>::value;
	std::vector<char> buffer(100, 0);		std::vector<uint8_t> buffer(10000, 0);

	// int_max + sizeof(int64) overflows int32		// int_max + sizeof(int64) overflows int32
	std::string_view bad_string{"badbeef", std::numeric_limits<int32_t>::max()};		std::string_view bad_string{"badbeef", std::numeric_limits<int32_t>::max()};
	@@ -118,15 +148,31 @@ TEST(Metadata, wouldOverflowName) {
	NameValue::encode(bad_string, buffer.data(), buffer.size()));		NameValue::encode(bad_string, buffer.data(), buffer.size()));
	}		}

			TEST(Metadata, setGetMismatchedWidthHight) {
			// Validates that the header is properly validated on decode
			using WidthValue = StandardMetadata<StandardMetadataType::WIDTH>::value;
			using HeightValue = StandardMetadata<StandardMetadataType::HEIGHT>::value;
			std::vector<uint8_t> buffer(10000, 0);

			EXPECT_EQ(8 + HeaderSize, WidthValue::encode(100, buffer.data(), buffer.size()));
			EXPECT_EQ(100, reinterpret_cast<uint64_t>(SkipHeader(buffer).data()));
			auto read = WidthValue::decode(buffer.data(), buffer.size());
			ASSERT_TRUE(read.has_value());
			EXPECT_EQ(100, *read);
			read = HeightValue::decode(buffer.data(), buffer.size());
			EXPECT_FALSE(read.has_value());
			}

	TEST(Metadata, setGetCompression) {		TEST(Metadata, setGetCompression) {
	using CompressionValue = StandardMetadata<StandardMetadataType::COMPRESSION>::value;		using CompressionValue = StandardMetadata<StandardMetadataType::COMPRESSION>::value;
	ExtendableType myCompression{"bestest_compression_ever", 42};		ExtendableType myCompression{"bestest_compression_ever", 42};
	std::vector<char> buffer(100, '\0');		std::vector<uint8_t> buffer(10000, 0);
	const int expectedSize = myCompression.name.length() + sizeof(int64_t) + sizeof(int64_t);		const int expectedSize =
			myCompression.name.length() + sizeof(int64_t) + sizeof(int64_t) + HeaderSize;
	EXPECT_EQ(expectedSize, CompressionValue::encode(myCompression, buffer.data(), 0));		EXPECT_EQ(expectedSize, CompressionValue::encode(myCompression, buffer.data(), 0));
	EXPECT_EQ(0, buffer[0]);		EXPECT_EQ(0, buffer[0]);
	EXPECT_EQ(expectedSize, CompressionValue::encode(myCompression, buffer.data(), buffer.size()));		EXPECT_EQ(expectedSize, CompressionValue::encode(myCompression, buffer.data(), buffer.size()));
	EXPECT_EQ(myCompression.name.length(), reinterpret_cast<int64_t>(buffer.data()));		EXPECT_EQ(myCompression.name.length(), reinterpret_cast<int64_t>(SkipHeader(buffer).data()));
	EXPECT_FALSE(CompressionValue::decode(buffer.data(), 0).has_value());		EXPECT_FALSE(CompressionValue::decode(buffer.data(), 0).has_value());
	auto read = CompressionValue::decode(buffer.data(), buffer.size());		auto read = CompressionValue::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	@@ -135,41 +181,25 @@ TEST(Metadata, setGetCompression) {

	TEST(Metadata, setGetPlaneLayout) {		TEST(Metadata, setGetPlaneLayout) {
	using PlaneLayoutValue = StandardMetadata<StandardMetadataType::PLANE_LAYOUTS>::value;		using PlaneLayoutValue = StandardMetadata<StandardMetadataType::PLANE_LAYOUTS>::value;
	PlaneLayout myPlaneLayout;
	myPlaneLayout.offsetInBytes = 10;
	myPlaneLayout.sampleIncrementInBits = 11;
	myPlaneLayout.strideInBytes = 12;
	myPlaneLayout.widthInSamples = 13;
	myPlaneLayout.heightInSamples = 14;
	myPlaneLayout.totalSizeInBytes = 15;
	myPlaneLayout.horizontalSubsampling = 16;
	myPlaneLayout.verticalSubsampling = 17;

	myPlaneLayout.components.resize(3);
	for (int i = 0; i < myPlaneLayout.components.size(); i++) {
	auto& it = myPlaneLayout.components[i];
	it.type = ExtendableType{"Plane ID", 40 + i};
	it.offsetInBits = 20 + i;
	it.sizeInBits = 30 + i;
	}

	std::vector<PlaneLayout> layouts{myPlaneLayout, PlaneLayout{}};		std::vector<PlaneLayout> layouts = fakePlaneLayouts();

	std::vector<char> buffer(5000, '\0');		std::vector<uint8_t> buffer(10000, 0);
	constexpr int componentSize = 8 + (4 * sizeof(int64_t));		constexpr int componentSize = 8 + (4 * sizeof(int64_t));
	constexpr int firstLayoutSize = (8 + 1) * sizeof(int64_t) + (3 * componentSize);		constexpr int firstLayoutSize = (8 + 1) * sizeof(int64_t) + (3 * componentSize);
	constexpr int secondLayoutSize = (8 + 1) * sizeof(int64_t);		constexpr int secondLayoutSize = (8 + 1) * sizeof(int64_t);
	constexpr int expectedSize = firstLayoutSize + secondLayoutSize + sizeof(int64_t);		constexpr int expectedSize = firstLayoutSize + secondLayoutSize + sizeof(int64_t) + HeaderSize;
	EXPECT_EQ(expectedSize, PlaneLayoutValue::encode(layouts, buffer.data(), 0));		EXPECT_EQ(expectedSize, PlaneLayoutValue::encode(layouts, buffer.data(), 0));
	EXPECT_EQ(0, buffer[0]);		EXPECT_EQ(0, buffer[0]);
	EXPECT_EQ(expectedSize, PlaneLayoutValue::encode(layouts, buffer.data(), buffer.size()));		EXPECT_EQ(expectedSize, PlaneLayoutValue::encode(layouts, buffer.data(), buffer.size()));
	EXPECT_EQ(3, reinterpret_cast<int64_t*>(buffer.data())[1]);		int64_t* payload = reinterpret_cast<int64_t*>(SkipHeader(buffer).data());
	EXPECT_EQ(8, reinterpret_cast<int64_t*>(buffer.data())[2]);		EXPECT_EQ(3, payload[1]);
	EXPECT_EQ(40, reinterpret_cast<int64_t*>(buffer.data())[4]);		EXPECT_EQ(8, payload[2]);
	EXPECT_EQ(31, reinterpret_cast<int64_t*>(buffer.data())[11]);		EXPECT_EQ(40, payload[4]);
	EXPECT_EQ(22, reinterpret_cast<int64_t*>(buffer.data())[15]);		EXPECT_EQ(31, payload[11]);
	EXPECT_EQ(10, reinterpret_cast<int64_t*>(buffer.data())[17]);		EXPECT_EQ(22, payload[15]);
	EXPECT_EQ(11, reinterpret_cast<int64_t*>(buffer.data())[18]);		EXPECT_EQ(10, payload[17]);
			EXPECT_EQ(11, payload[18]);
	EXPECT_FALSE(PlaneLayoutValue::decode(buffer.data(), 0).has_value());		EXPECT_FALSE(PlaneLayoutValue::decode(buffer.data(), 0).has_value());
	auto read = PlaneLayoutValue::decode(buffer.data(), buffer.size());		auto read = PlaneLayoutValue::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	@@ -178,15 +208,15 @@ TEST(Metadata, setGetPlaneLayout) {

	TEST(Metadata, setGetRects) {		TEST(Metadata, setGetRects) {
	using RectsValue = StandardMetadata<StandardMetadataType::CROP>::value;		using RectsValue = StandardMetadata<StandardMetadataType::CROP>::value;
	std::vector<uint8_t> buffer(500, 0);		std::vector<uint8_t> buffer(10000, 0);
	std::vector<Rect> cropRects{2};		std::vector<Rect> cropRects{2};
	cropRects[0] = Rect{10, 11, 12, 13};		cropRects[0] = Rect{10, 11, 12, 13};
	cropRects[1] = Rect{20, 21, 22, 23};		cropRects[1] = Rect{20, 21, 22, 23};

	constexpr int expectedSize = sizeof(int64_t) + (8 * sizeof(int32_t));		constexpr int expectedSize = sizeof(int64_t) + (8 * sizeof(int32_t)) + HeaderSize;
	EXPECT_EQ(expectedSize, RectsValue::encode(cropRects, buffer.data(), buffer.size()));		EXPECT_EQ(expectedSize, RectsValue::encode(cropRects, buffer.data(), buffer.size()));
	EXPECT_EQ(2, reinterpret_cast<int64_t*>(buffer.data())[0]);		EXPECT_EQ(2, reinterpret_cast<int64_t*>(SkipHeader(buffer).data())[0]);
	EXPECT_EQ(10, reinterpret_cast<int32_t*>(buffer.data())[2]);		EXPECT_EQ(10, reinterpret_cast<int32_t*>(SkipHeader(buffer).data())[2]);
	auto read = RectsValue::decode(buffer.data(), buffer.size());		auto read = RectsValue::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	EXPECT_EQ(cropRects.size(), read->size());		EXPECT_EQ(cropRects.size(), read->size());
	@@ -203,8 +233,8 @@ TEST(Metadata, setGetSmpte2086) {
	source.primaryGreen = XyColor{.3f, .4f};		source.primaryGreen = XyColor{.3f, .4f};
	source.primaryBlue = XyColor{.5f, .6f};		source.primaryBlue = XyColor{.5f, .6f};

	constexpr int expectedSize = 10 * sizeof(float);		constexpr int expectedSize = 10 * sizeof(float) + HeaderSize;
	std::vector<uint8_t> buffer(500, 0);		std::vector<uint8_t> buffer(10000, 0);
	EXPECT_EQ(expectedSize, Smpte2086Value::encode(source, buffer.data(), buffer.size()));		EXPECT_EQ(expectedSize, Smpte2086Value::encode(source, buffer.data(), buffer.size()));
	auto read = Smpte2086Value::decode(buffer.data(), buffer.size());		auto read = Smpte2086Value::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	@@ -223,8 +253,8 @@ TEST(Metadata, setGetCta861_3) {
	source.maxFrameAverageLightLevel = 244.55f;		source.maxFrameAverageLightLevel = 244.55f;
	source.maxContentLightLevel = 202.202f;		source.maxContentLightLevel = 202.202f;

	constexpr int expectedSize = 2 * sizeof(float);		constexpr int expectedSize = 2 * sizeof(float) + HeaderSize;
	std::vector<uint8_t> buffer(500, 0);		std::vector<uint8_t> buffer(10000, 0);
	EXPECT_EQ(expectedSize, Cta861_3Value::encode(source, buffer.data(), buffer.size()));		EXPECT_EQ(expectedSize, Cta861_3Value::encode(source, buffer.data(), buffer.size()));
	auto read = Cta861_3Value::decode(buffer.data(), buffer.size());		auto read = Cta861_3Value::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	@@ -240,14 +270,14 @@ TEST(Metadata, setGetCta861_3) {
	TEST(Metadata, setGetSmpte2094_10) {		TEST(Metadata, setGetSmpte2094_10) {
	using SMPTE2094_10Value = StandardMetadata<StandardMetadataType::SMPTE2094_10>::value;		using SMPTE2094_10Value = StandardMetadata<StandardMetadataType::SMPTE2094_10>::value;

	std::vector<uint8_t> buffer(500, 0);		std::vector<uint8_t> buffer(10000, 0);
	EXPECT_EQ(0, SMPTE2094_10Value::encode(std::nullopt, buffer.data(), buffer.size()));		EXPECT_EQ(0, SMPTE2094_10Value::encode(std::nullopt, buffer.data(), buffer.size()));
	auto read = SMPTE2094_10Value::decode(buffer.data(), 0);		auto read = SMPTE2094_10Value::decode(buffer.data(), 0);
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	EXPECT_FALSE(read->has_value());		EXPECT_FALSE(read->has_value());

	const std::vector<uint8_t> emptyBuffer;		const std::vector<uint8_t> emptyBuffer;
	EXPECT_EQ(sizeof(int64_t),		EXPECT_EQ(sizeof(int64_t) + HeaderSize,
	SMPTE2094_10Value::encode(emptyBuffer, buffer.data(), buffer.size()));		SMPTE2094_10Value::encode(emptyBuffer, buffer.data(), buffer.size()));
	read = SMPTE2094_10Value::decode(buffer.data(), buffer.size());		read = SMPTE2094_10Value::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	@@ -255,7 +285,7 @@ TEST(Metadata, setGetSmpte2094_10) {
	EXPECT_EQ(0, read->value().size());		EXPECT_EQ(0, read->value().size());

	const std::vector<uint8_t> simpleBuffer{0, 1, 2, 3, 4, 5};		const std::vector<uint8_t> simpleBuffer{0, 1, 2, 3, 4, 5};
	EXPECT_EQ(sizeof(int64_t) + 6,		EXPECT_EQ(sizeof(int64_t) + 6 + HeaderSize,
	SMPTE2094_10Value::encode(simpleBuffer, buffer.data(), buffer.size()));		SMPTE2094_10Value::encode(simpleBuffer, buffer.data(), buffer.size()));
	read = SMPTE2094_10Value::decode(buffer.data(), buffer.size());		read = SMPTE2094_10Value::decode(buffer.data(), buffer.size());
	ASSERT_TRUE(read.has_value());		ASSERT_TRUE(read.has_value());
	@@ -266,7 +296,7 @@ TEST(Metadata, setGetSmpte2094_10) {

	TEST(MetadataProvider, bufferId) {		TEST(MetadataProvider, bufferId) {
	using BufferId = StandardMetadata<StandardMetadataType::BUFFER_ID>::value;		using BufferId = StandardMetadata<StandardMetadataType::BUFFER_ID>::value;
	std::vector<uint8_t> buffer(500, 0);		std::vector<uint8_t> buffer(10000, 0);
	int result = provideStandardMetadata(StandardMetadataType::BUFFER_ID, buffer.data(),		int result = provideStandardMetadata(StandardMetadataType::BUFFER_ID, buffer.data(),
	buffer.size(), []<StandardMetadataType T>(auto&& provide) {		buffer.size(), []<StandardMetadataType T>(auto&& provide) {
	if constexpr (T == StandardMetadataType::BUFFER_ID) {		if constexpr (T == StandardMetadataType::BUFFER_ID) {
	@@ -275,7 +305,7 @@ TEST(MetadataProvider, bufferId) {
	return 0;		return 0;
	});		});

	EXPECT_EQ(8, result);		EXPECT_EQ(8 + HeaderSize, result);
	auto read = BufferId::decode(buffer.data(), buffer.size());		auto read = BufferId::decode(buffer.data(), buffer.size());
	EXPECT_EQ(42, read.value_or(0));		EXPECT_EQ(42, read.value_or(0));
	}		}
	@@ -312,3 +342,193 @@ TEST(MetadataProvider, outOfBounds) {
	EXPECT_EQ(-AIMAPPER_ERROR_UNSUPPORTED, result)		EXPECT_EQ(-AIMAPPER_ERROR_UNSUPPORTED, result)
	<< "100 (out of range) should have resulted in UNSUPPORTED";		<< "100 (out of range) should have resulted in UNSUPPORTED";
	}		}

			template <StandardMetadataType T>
			std::vector<uint8_t> encode(const typename StandardMetadata<T>::value_type& value) {
			using Value = typename StandardMetadata<T>::value;

			int desiredSize = Value::encode(value, nullptr, 0);
			EXPECT_GE(desiredSize, 0);
			std::vector<uint8_t> buffer;
			buffer.resize(desiredSize);
			EXPECT_EQ(desiredSize, Value::encode(value, buffer.data(), buffer.size()));
			return buffer;
			}

			TEST(MetadataGralloc4Interop, BufferId) {
			auto mpbuf = encode<StandardMetadataType::BUFFER_ID>(42);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeBufferId(42, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Name) {
			auto mpbuf = encode<StandardMetadataType::NAME>("Hello, Interop!");
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeName("Hello, Interop!", &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Width) {
			auto mpbuf = encode<StandardMetadataType::WIDTH>(128);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeWidth(128, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Height) {
			auto mpbuf = encode<StandardMetadataType::HEIGHT>(64);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeHeight(64, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, LayerCount) {
			auto mpbuf = encode<StandardMetadataType::LAYER_COUNT>(3);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeLayerCount(3, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, PixelFormatRequested) {
			auto mpbuf = encode<StandardMetadataType::PIXEL_FORMAT_REQUESTED>(PixelFormat::RGBX_8888);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodePixelFormatRequested(
			hardware::graphics::common::V1_2::PixelFormat::RGBX_8888, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, PixelFormatFourcc) {
			auto mpbuf = encode<StandardMetadataType::PIXEL_FORMAT_FOURCC>(DRM_FORMAT_ABGR8888);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodePixelFormatFourCC(DRM_FORMAT_ABGR8888, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, PixelFormatModifier) {
			auto mpbuf = encode<StandardMetadataType::PIXEL_FORMAT_MODIFIER>(123456);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodePixelFormatModifier(123456, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Usage) {
			auto mpbuf = encode<StandardMetadataType::USAGE>(BufferUsage::COMPOSER_OVERLAY);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR,
			gralloc4::encodeUsage(
			static_cast<uint64_t>(
			hardware::graphics::common::V1_2::BufferUsage::COMPOSER_OVERLAY),
			&g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, AllocationSize) {
			auto mpbuf = encode<StandardMetadataType::ALLOCATION_SIZE>(10200);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeAllocationSize(10200, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, ProtectedContent) {
			auto mpbuf = encode<StandardMetadataType::PROTECTED_CONTENT>(1);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeProtectedContent(1, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Compression) {
			auto mpbuf = encode<StandardMetadataType::COMPRESSION>(
			gralloc4::Compression_DisplayStreamCompression);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR,
			gralloc4::encodeCompression(gralloc4::Compression_DisplayStreamCompression, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Interlaced) {
			auto mpbuf = encode<StandardMetadataType::INTERLACED>(gralloc4::Interlaced_TopBottom);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeInterlaced(gralloc4::Interlaced_TopBottom, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, ChromeSitting) {
			auto mpbuf =
			encode<StandardMetadataType::CHROMA_SITING>(gralloc4::ChromaSiting_SitedInterstitial);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR,
			gralloc4::encodeChromaSiting(gralloc4::ChromaSiting_SitedInterstitial, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, PlaneLayouts) {
			auto mpbuf = encode<StandardMetadataType::PLANE_LAYOUTS>(fakePlaneLayouts());
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodePlaneLayouts(fakePlaneLayouts(), &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Crop) {
			std::vector<Rect> cropRects{Rect{10, 11, 12, 13}, Rect{20, 21, 22, 23}};
			auto mpbuf = encode<StandardMetadataType::CROP>(cropRects);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeCrop(cropRects, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Dataspace) {
			auto mpbuf = encode<StandardMetadataType::DATASPACE>(Dataspace::DISPLAY_P3);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeDataspace(Dataspace::DISPLAY_P3, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, BlendMode) {
			auto mpbuf = encode<StandardMetadataType::BLEND_MODE>(BlendMode::PREMULTIPLIED);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeBlendMode(BlendMode::PREMULTIPLIED, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Smpte2086) {
			Smpte2086 hdrdata{XyColor{.1f, .2f}, XyColor{.3f, .4f}, XyColor{.5f, .6f},
			XyColor{.7f, .8f}, 452.889f, 12.335f};

			auto mpbuf = encode<StandardMetadataType::SMPTE2086>(hdrdata);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeSmpte2086(hdrdata, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Cta861_3) {
			Cta861_3 hdrdata{302.202f, 244.55f};
			auto mpbuf = encode<StandardMetadataType::CTA861_3>(hdrdata);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeCta861_3(hdrdata, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Smpte2094_10) {
			auto mpbuf = encode<StandardMetadataType::SMPTE2094_10>(std::nullopt);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeSmpte2094_10(std::nullopt, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);

			std::vector<uint8_t> hdrdata{1, 2, 3, 4, 5, 6};
			mpbuf = encode<StandardMetadataType::SMPTE2094_10>(hdrdata);
			ASSERT_EQ(NO_ERROR, gralloc4::encodeSmpte2094_10(hdrdata, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}

			TEST(MetadataGralloc4Interop, Smpte2094_40) {
			auto mpbuf = encode<StandardMetadataType::SMPTE2094_40>(std::nullopt);
			hidl_vec<uint8_t> g4buf;
			ASSERT_EQ(NO_ERROR, gralloc4::encodeSmpte2094_40(std::nullopt, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);

			std::vector<uint8_t> hdrdata{1, 2, 3, 4, 5, 6};
			mpbuf = encode<StandardMetadataType::SMPTE2094_40>(hdrdata);
			ASSERT_EQ(NO_ERROR, gralloc4::encodeSmpte2094_40(hdrdata, &g4buf));
			EXPECT_EQ(mpbuf, g4buf);
			}