Merge "Setting layer dataspace to match the color mode" (faaaa27c) · Commits · e / os / android_hardware_interfaces

graphics/composer/2.2/utils/vts/ReadbackVts.cpp

+6 −1

Original line number	Diff line number	Diff line
		@@ -287,7 +287,6 @@ TestBufferLayer::~TestBufferLayer() {
		void TestBufferLayer::write(const std::shared_ptr<CommandWriterBase>& writer) {
		TestLayer::write(writer);
		writer->setLayerCompositionType(mComposition);
		writer->setLayerDataspace(Dataspace::UNKNOWN);
		writer->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, mDisplayFrame));
		if (mBufferHandle != nullptr) writer->setLayerBuffer(0, mBufferHandle, mFillFence);
		}
		@@ -337,6 +336,12 @@ void TestBufferLayer::setBuffer(std::vector<IComposerClient::Color> colors) {
		mFormat, mUsage, mStride));
		}

		void TestBufferLayer::setDataspace(Dataspace dataspace,
		const std::shared_ptr<CommandWriterBase>& writer) {
		writer->selectLayer(mLayer);
		writer->setLayerDataspace(dataspace);
		}

		void TestBufferLayer::setToClientComposition(const std::shared_ptr<CommandWriterBase>& writer) {
		writer->selectLayer(mLayer);
		writer->setLayerCompositionType(IComposerClient::Composition::CLIENT);

graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ReadbackVts.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -123,6 +123,8 @@ class TestBufferLayer : public TestLayer {

		void setBuffer(std::vector<IComposerClient::Color> colors);

		void setDataspace(Dataspace dataspace, const std::shared_ptr<CommandWriterBase>& writer);

		void setToClientComposition(const std::shared_ptr<CommandWriterBase>& writer);

		uint32_t mWidth;

graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2ReadbackTest.cpp

+290 −172

Original line number	Diff line number	Diff line
		@@ -268,6 +268,7 @@ TEST_F(GraphicsComposerReadbackTest, SetLayerBuffer) {
		PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));

		std::vector<std::shared_ptr<TestLayer>> layers = {layer};
		@@ -398,6 +399,7 @@ TEST_F(GraphicsComposerReadbackTest, ClientComposition) {
		PixelFormat::RGBA_FP16);
		layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

		std::vector<std::shared_ptr<TestLayer>> layers = {layer};

		@@ -519,6 +521,7 @@ TEST_F(GraphicsComposerReadbackTest, DeviceAndClientComposition) {
		deviceLayer->setDisplayFrame({0, 0, static_cast<int32_t>(deviceLayer->mWidth),
		static_cast<int32_t>(deviceLayer->mHeight)});
		deviceLayer->setZOrder(10);
		deviceLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		ASSERT_NO_FATAL_FAILURE(deviceLayer->setBuffer(deviceColors));
		deviceLayer->write(mWriter);

		@@ -631,6 +634,7 @@ TEST_F(GraphicsComposerReadbackTest, SetLayerDamage) {
		PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));

		std::vector<std::shared_ptr<TestLayer>> layers = {layer};
		@@ -775,6 +779,7 @@ TEST_F(GraphicsComposerReadbackTest, SetLayerSourceCrop) {
		PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		layer->setSourceCrop({0, static_cast<float>(mDisplayHeight / 2),
		static_cast<float>(mDisplayWidth),
		static_cast<float>(mDisplayHeight)});
		@@ -894,6 +899,7 @@ class GraphicsComposerBlendModeReadbackTest : public GraphicsComposerReadbackTes
		public:
		void SetUp() override {
		GraphicsComposerReadbackTest::SetUp();
		mTestColorModes = {ColorMode::SRGB}; // TODO: add more color mode support
		mBackgroundColor = BLACK;
		mTopLayerColor = RED;
		}
		@@ -920,6 +926,7 @@ class GraphicsComposerBlendModeReadbackTest : public GraphicsComposerReadbackTes
		PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
		layer->setZOrder(10);
		layer->setDataspace(Dataspace::UNKNOWN, mWriter);
		ASSERT_NO_FATAL_FAILURE(layer->setBuffer(topLayerPixelColors));

		layer->setBlendMode(blendMode);
		@@ -970,7 +977,24 @@ class GraphicsComposerBlendModeReadbackTest : public GraphicsComposerReadbackTes
		};

		TEST_P(GraphicsComposerBlendModeReadbackTest, None) {
		for (ColorMode mode : mTestColorModes) {
		std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
		<< std::endl;
		mWriter->selectDisplay(mPrimaryDisplay);
		ASSERT_NO_FATAL_FAILURE(
		mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));

		mComposerClient->getRaw()->getReadbackBufferAttributes(
		mPrimaryDisplay,
		[&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
		mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
		tmpDataspace, tmpError);
		mPixelFormat = tmpPixelFormat;
		mDataspace = tmpDataspace;
		});

		if (!mHasReadbackBuffer) {
		std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
		GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
		return;
		}
		@@ -1003,11 +1027,29 @@ TEST_P(GraphicsComposerBlendModeReadbackTest, None) {

		ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
		}
		}

		// TODO: bug 116865056: Readback returns (245, 0, 0) for layer plane
		// alpha of .2, expected 10.2
		TEST_P(GraphicsComposerBlendModeReadbackTest, DISABLED_Coverage) {
		for (ColorMode mode : mTestColorModes) {
		std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
		<< std::endl;
		mWriter->selectDisplay(mPrimaryDisplay);
		ASSERT_NO_FATAL_FAILURE(
		mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));

		mComposerClient->getRaw()->getReadbackBufferAttributes(
		mPrimaryDisplay,
		[&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
		mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
		tmpDataspace, tmpError);
		mPixelFormat = tmpPixelFormat;
		mDataspace = tmpDataspace;
		});

		if (!mHasReadbackBuffer) {
		std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
		GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
		return;
		}
		@@ -1040,13 +1082,30 @@ TEST_P(GraphicsComposerBlendModeReadbackTest, DISABLED_Coverage) {
		ASSERT_EQ(0, mReader->mErrors.size());
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
		}
		}

		TEST_P(GraphicsComposerBlendModeReadbackTest, Premultiplied) {
		for (ColorMode mode : mTestColorModes) {
		std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
		<< std::endl;
		mWriter->selectDisplay(mPrimaryDisplay);
		ASSERT_NO_FATAL_FAILURE(
		mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));

		mComposerClient->getRaw()->getReadbackBufferAttributes(
		mPrimaryDisplay,
		[&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
		mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
		tmpDataspace, tmpError);
		mPixelFormat = tmpPixelFormat;
		mDataspace = tmpDataspace;
		});

		if (!mHasReadbackBuffer) {
		std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
		GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
		return;
		}

		mWriter->selectDisplay(mPrimaryDisplay);

		std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
		@@ -1074,6 +1133,7 @@ TEST_P(GraphicsComposerBlendModeReadbackTest, Premultiplied) {
		ASSERT_EQ(0, mReader->mErrors.size());
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
		}
		}

		INSTANTIATE_TEST_CASE_P(BlendModeTest, GraphicsComposerBlendModeReadbackTest,
		::testing::Values(.2, 1.0));
		@@ -1117,7 +1177,24 @@ class GraphicsComposerTransformReadbackTest : public GraphicsComposerReadbackTes
		};

		TEST_F(GraphicsComposerTransformReadbackTest, FLIP_H) {
		for (ColorMode mode : mTestColorModes) {
		std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
		<< std::endl;
		mWriter->selectDisplay(mPrimaryDisplay);
		ASSERT_NO_FATAL_FAILURE(
		mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));

		mComposerClient->getRaw()->getReadbackBufferAttributes(
		mPrimaryDisplay,
		[&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
		mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
		tmpDataspace, tmpError);
		mPixelFormat = tmpPixelFormat;
		mDataspace = tmpDataspace;
		});

		if (!mHasReadbackBuffer) {
		std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
		GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
		return;
		}
		@@ -1125,6 +1202,8 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_H) {
		mDisplayHeight, mPixelFormat, mDataspace);
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
		mLayer->setTransform(Transform::FLIP_H);
		mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

		std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
		ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
		{mSideLength / 2, 0, mSideLength, mSideLength / 2}, RED);
		@@ -1147,9 +1226,27 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_H) {

		ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
		}
		}

		TEST_F(GraphicsComposerTransformReadbackTest, FLIP_V) {
		for (ColorMode mode : mTestColorModes) {
		std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
		<< std::endl;
		mWriter->selectDisplay(mPrimaryDisplay);
		ASSERT_NO_FATAL_FAILURE(
		mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));

		mComposerClient->getRaw()->getReadbackBufferAttributes(
		mPrimaryDisplay,
		[&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
		mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
		tmpDataspace, tmpError);
		mPixelFormat = tmpPixelFormat;
		mDataspace = tmpDataspace;
		});

		if (!mHasReadbackBuffer) {
		std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
		GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
		return;
		}
		@@ -1158,6 +1255,7 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_V) {
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());

		mLayer->setTransform(Transform::FLIP_V);
		mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

		std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
		ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
		@@ -1180,9 +1278,27 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_V) {
		ASSERT_EQ(0, mReader->mErrors.size());
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
		}
		}

		TEST_F(GraphicsComposerTransformReadbackTest, ROT_180) {
		for (ColorMode mode : mTestColorModes) {
		std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
		<< std::endl;
		mWriter->selectDisplay(mPrimaryDisplay);
		ASSERT_NO_FATAL_FAILURE(
		mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));

		mComposerClient->getRaw()->getReadbackBufferAttributes(
		mPrimaryDisplay,
		[&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
		mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
		tmpDataspace, tmpError);
		mPixelFormat = tmpPixelFormat;
		mDataspace = tmpDataspace;
		});

		if (!mHasReadbackBuffer) {
		std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
		GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
		return;
		}
		@@ -1191,6 +1307,7 @@ TEST_F(GraphicsComposerTransformReadbackTest, ROT_180) {
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());

		mLayer->setTransform(Transform::ROT_180);
		mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

		std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
		ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
		@@ -1214,6 +1331,7 @@ TEST_F(GraphicsComposerTransformReadbackTest, ROT_180) {
		ASSERT_EQ(0, mReader->mErrors.size());
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
		}
		}

		} // anonymous namespace
		} // namespace vts