Merge "Clean up the GraphicBuffer." (9a034e45) · Commits · e / os / android_hardware_interfaces

graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp

+57 −66

Original line number	Diff line number	Diff line
		@@ -62,9 +62,6 @@ class GraphicsCompositionTestBase : public ::testing::Test {
		}
		mComposerClient->setVsyncAllowed(/isAllowed/ false);

		// set up gralloc
		mGraphicBuffer = allocate();

		EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());

		ASSERT_NO_FATAL_FAILURE(
		@@ -112,15 +109,18 @@ class GraphicsCompositionTestBase : public ::testing::Test {

		int32_t getDisplayHeight() const { return getPrimaryDisplay().getDisplayHeight(); }

		::android::sp<::android::GraphicBuffer> allocate() {
		std::pair<bool, ::android::sp<::android::GraphicBuffer>> allocateBuffer(uint32_t usage) {
		const auto width = static_cast<uint32_t>(getDisplayWidth());
		const auto height = static_cast<uint32_t>(getDisplayHeight());
		const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) \|
		static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);

		return ::android::sp<::android::GraphicBuffer>::make(
		const auto& graphicBuffer = ::android::sp<::android::GraphicBuffer>::make(
		width, height, ::android::PIXEL_FORMAT_RGBA_8888,
		/layerCount/ 1u, usage, "VtsHalGraphicsComposer3_ReadbackTest");

		if (graphicBuffer && ::android::OK == graphicBuffer->initCheck()) {
		return {true, graphicBuffer};
		}
		return {false, graphicBuffer};
		}

		uint64_t getStableDisplayId(int64_t display) {
		@@ -231,7 +231,6 @@ class GraphicsCompositionTestBase : public ::testing::Test {
		std::vector<ColorMode> mTestColorModes;
		ComposerClientWriter mWriter;
		ComposerClientReader mReader;
		::android::sp<::android::GraphicBuffer> mGraphicBuffer;
		std::unique_ptr<TestRenderEngine> mTestRenderEngine;
		common::PixelFormat mPixelFormat;
		common::Dataspace mDataspace;
		@@ -339,8 +338,8 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) {
		{0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);

		auto layer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		getDisplayWidth(), getDisplayHeight(), common::PixelFormat::RGBA_8888);
		mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
		getDisplayHeight(), common::PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		@@ -392,15 +391,12 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) {
		layer->write(mWriter);

		// This following buffer call should have no effect
		uint64_t usage =
		static_cast<uint64_t>(static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) \|
		static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN));

		mGraphicBuffer->reallocate(static_cast<uint32_t>(getDisplayWidth()),
		static_cast<uint32_t>(getDisplayHeight()), 1,
		static_cast<uint32_t>(common::PixelFormat::RGBA_8888), usage);
		mWriter.setLayerBuffer(getPrimaryDisplayId(), layer->getLayer(), /slot/ 0,
		mGraphicBuffer->handle,
		const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) \|
		static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
		const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage);
		ASSERT_TRUE(graphicBufferStatus);
		const auto& buffer = graphicBuffer->handle;
		mWriter.setLayerBuffer(getPrimaryDisplayId(), layer->getLayer(), /slot/ 0, buffer,
		/acquireFence/ -1);

		// expected color for each pixel
		@@ -450,9 +446,11 @@ TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadDisplay) {
		return;
		}

		ASSERT_NE(nullptr, mGraphicBuffer);
		ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
		const auto& bufferHandle = mGraphicBuffer->handle;
		const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) \|
		static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
		const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage);
		ASSERT_TRUE(graphicBufferStatus);
		const auto& bufferHandle = graphicBuffer->handle;
		::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1);

		const auto status =
		@@ -523,9 +521,9 @@ TEST_P(GraphicsCompositionTest, ClientComposition) {
		expectedColors, getDisplayWidth(),
		{0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);

		auto layer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_FP16);
		auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
		getPrimaryDisplayId(), getDisplayWidth(),
		getDisplayHeight(), PixelFormat::RGBA_FP16);
		layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		@@ -554,20 +552,17 @@ TEST_P(GraphicsCompositionTest, ClientComposition) {
		common::Rect damage{0, 0, getDisplayWidth(), getDisplayHeight()};

		// create client target buffer
		mGraphicBuffer->reallocate(layer->getWidth(), layer->getHeight(),
		static_cast<int32_t>(common::PixelFormat::RGBA_8888),
		layer->getLayerCount(), clientUsage);

		ASSERT_NE(nullptr, mGraphicBuffer->handle);

		const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage);
		ASSERT_TRUE(graphicBufferStatus);
		const auto& buffer = graphicBuffer->handle;
		void* clientBufData;
		mGraphicBuffer->lock(clientUsage, layer->getAccessRegion(), &clientBufData);
		const auto stride = static_cast<uint32_t>(graphicBuffer->stride);
		graphicBuffer->lock(clientUsage, layer->getAccessRegion(), &clientBufData);

		ASSERT_NO_FATAL_FAILURE(
		ReadbackHelper::fillBuffer(layer->getWidth(), layer->getHeight(),
		static_cast<uint32_t>(mGraphicBuffer->stride),
		ReadbackHelper::fillBuffer(layer->getWidth(), layer->getHeight(), stride,
		clientBufData, clientFormat, expectedColors));
		EXPECT_EQ(::android::OK, mGraphicBuffer->unlock());
		EXPECT_EQ(::android::OK, graphicBuffer->unlock());

		const auto& [status, bufferFence] =
		mComposerClient->getReadbackBufferFence(getPrimaryDisplayId());
		@@ -575,9 +570,8 @@ TEST_P(GraphicsCompositionTest, ClientComposition) {

		layer->setToClientComposition(mWriter);
		mWriter.acceptDisplayChanges(getPrimaryDisplayId());
		mWriter.setClientTarget(getPrimaryDisplayId(), /slot/ 0, mGraphicBuffer->handle,
		bufferFence.get(), clientDataspace,
		std::vector<common::Rect>(1, damage));
		mWriter.setClientTarget(getPrimaryDisplayId(), /slot/ 0, buffer, bufferFence.get(),
		clientDataspace, std::vector<common::Rect>(1, damage));
		execute();
		changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
		ASSERT_TRUE(changedCompositionTypes.empty());
		@@ -623,8 +617,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
		ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());

		auto deviceLayer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		getDisplayWidth(), getDisplayHeight() / 2, PixelFormat::RGBA_8888);
		mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
		getDisplayHeight() / 2, PixelFormat::RGBA_8888);
		std::vector<Color> deviceColors(deviceLayer->getWidth() * deviceLayer->getHeight());
		ReadbackHelper::fillColorsArea(deviceColors, static_cast<int32_t>(deviceLayer->getWidth()),
		{0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
		@@ -647,8 +641,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
		int32_t clientHeight = getDisplayHeight() / 2;

		auto clientLayer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		clientWidth, clientHeight, PixelFormat::RGBA_FP16, Composition::DEVICE);
		mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), clientWidth,
		clientHeight, PixelFormat::RGBA_FP16, Composition::DEVICE);
		common::Rect clientFrame = {0, getDisplayHeight() / 2, getDisplayWidth(),
		getDisplayHeight()};
		clientLayer->setDisplayFrame(clientFrame);
		@@ -663,14 +657,12 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
		}
		// create client target buffer
		ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
		mGraphicBuffer->reallocate(static_cast<uint32_t>(getDisplayWidth()),
		static_cast<uint32_t>(getDisplayHeight()),
		static_cast<int32_t>(common::PixelFormat::RGBA_8888),
		clientLayer->getLayerCount(), clientUsage);
		ASSERT_NE(nullptr, mGraphicBuffer->handle);
		const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage);
		ASSERT_TRUE(graphicBufferStatus);
		const auto& buffer = graphicBuffer->handle;

		void* clientBufData;
		mGraphicBuffer->lock(clientUsage, {0, 0, getDisplayWidth(), getDisplayHeight()},
		graphicBuffer->lock(clientUsage, {0, 0, getDisplayWidth(), getDisplayHeight()},
		&clientBufData);

		std::vector<Color> clientColors(
		@@ -678,8 +670,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
		ReadbackHelper::fillColorsArea(clientColors, getDisplayWidth(), clientFrame, RED);
		ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(
		static_cast<uint32_t>(getDisplayWidth()), static_cast<uint32_t>(getDisplayHeight()),
		mGraphicBuffer->getStride(), clientBufData, clientFormat, clientColors));
		EXPECT_EQ(::android::OK, mGraphicBuffer->unlock());
		graphicBuffer->getStride(), clientBufData, clientFormat, clientColors));
		EXPECT_EQ(::android::OK, graphicBuffer->unlock());

		const auto& [status, bufferFence] =
		mComposerClient->getReadbackBufferFence(getPrimaryDisplayId());
		@@ -687,9 +679,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {

		clientLayer->setToClientComposition(mWriter);
		mWriter.acceptDisplayChanges(getPrimaryDisplayId());
		mWriter.setClientTarget(getPrimaryDisplayId(), /slot/ 0, mGraphicBuffer->handle,
		bufferFence.get(), clientDataspace,
		std::vector<common::Rect>(1, clientFrame));
		mWriter.setClientTarget(getPrimaryDisplayId(), /slot/ 0, buffer, bufferFence.get(),
		clientDataspace, std::vector<common::Rect>(1, clientFrame));
		execute();
		changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
		ASSERT_TRUE(changedCompositionTypes.empty());
		@@ -721,9 +712,9 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) {
		static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
		ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);

		auto layer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_8888);
		auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
		getPrimaryDisplayId(), getDisplayWidth(),
		getDisplayHeight(), PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		@@ -849,9 +840,9 @@ TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) {
		expectedColors, getDisplayWidth(),
		{0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);

		auto layer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_8888);
		auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
		getPrimaryDisplayId(), getDisplayWidth(),
		getDisplayHeight(), PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
		layer->setZOrder(10);
		layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
		@@ -1083,9 +1074,9 @@ class GraphicsBlendModeCompositionTest
		backgroundLayer->setZOrder(0);
		backgroundLayer->setColor(mBackgroundColor);

		auto layer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_8888);
		auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
		getPrimaryDisplayId(), getDisplayWidth(),
		getDisplayHeight(), PixelFormat::RGBA_8888);
		layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
		layer->setZOrder(10);
		layer->setDataspace(Dataspace::UNKNOWN, mWriter);
		@@ -1283,9 +1274,9 @@ class GraphicsTransformCompositionTest : public GraphicsCompositionTest {
		common::Rect redRect = {0, 0, mSideLength / 2, mSideLength / 2};
		common::Rect blueRect = {mSideLength / 2, mSideLength / 2, mSideLength, mSideLength};

		mLayer = std::make_shared<TestBufferLayer>(
		mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
		mSideLength, mSideLength, PixelFormat::RGBA_8888);
		mLayer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
		getPrimaryDisplayId(), mSideLength, mSideLength,
		PixelFormat::RGBA_8888);
		mLayer->setDisplayFrame({0, 0, mSideLength, mSideLength});
		mLayer->setZOrder(10);

graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp

+21 −12

Original line number	Diff line number	Diff line
		@@ -209,14 +209,14 @@ ReadbackBuffer::ReadbackBuffer(int64_t display, const std::shared_ptr<VtsCompose
		mAccessRegion.bottom = static_cast<int32_t>(height);
		}

		::android::sp<::android::GraphicBuffer> ReadbackBuffer::allocate() {
		::android::sp<::android::GraphicBuffer> ReadbackBuffer::allocateBuffer() {
		return ::android::sp<::android::GraphicBuffer>::make(
		mWidth, mHeight, static_cast<::android::PixelFormat>(mPixelFormat), mLayerCount, mUsage,
		"ReadbackVts");
		"ReadbackBuffer");
		}

		void ReadbackBuffer::setReadbackBuffer() {
		mGraphicBuffer = allocate();
		mGraphicBuffer = allocateBuffer();
		ASSERT_NE(nullptr, mGraphicBuffer);
		ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
		const auto& bufferHandle = mGraphicBuffer->handle;
		@@ -262,12 +262,10 @@ LayerSettings TestColorLayer::toRenderEngineLayerSettings() {
		}

		TestBufferLayer::TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
		const ::android::sp<::android::GraphicBuffer>& graphicBuffer,
		TestRenderEngine& renderEngine, int64_t display, uint32_t width,
		uint32_t height, common::PixelFormat format,
		Composition composition)
		: TestLayer{client, display}, mRenderEngine(renderEngine) {
		mGraphicBuffer = graphicBuffer;
		mComposition = composition;
		mWidth = width;
		mHeight = height;
		@@ -290,8 +288,9 @@ void TestBufferLayer::write(ComposerClientWriter& writer) {
		TestLayer::write(writer);
		writer.setLayerCompositionType(mDisplay, mLayer, mComposition);
		writer.setLayerVisibleRegion(mDisplay, mLayer, std::vector<Rect>(1, mDisplayFrame));
		if (mGraphicBuffer->handle != nullptr)
		writer.setLayerBuffer(mDisplay, mLayer, 0, mGraphicBuffer->handle, mFillFence);
		if (mGraphicBuffer) {
		writer.setLayerBuffer(mDisplay, mLayer, /slot/ 0, mGraphicBuffer->handle, mFillFence);
		}
		}

		LayerSettings TestBufferLayer::toRenderEngineLayerSettings() {
		@@ -326,16 +325,26 @@ void TestBufferLayer::fillBuffer(std::vector<Color>& expectedColors) {
		EXPECT_EQ(::android::OK, status);
		ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(mWidth, mHeight, stride, bufData,
		mPixelFormat, expectedColors));
		EXPECT_EQ(::android::OK, mGraphicBuffer->unlock());

		const auto unlockStatus = mGraphicBuffer->unlockAsync(&mFillFence);
		ASSERT_EQ(::android::OK, unlockStatus);
		if (mFillFence >= 0) {
		sync_wait(mFillFence, -1);
		close(mFillFence);
		}
		}

		void TestBufferLayer::setBuffer(std::vector<Color> colors) {
		mGraphicBuffer->reallocate(mWidth, mHeight, static_cast<::android::PixelFormat>(mPixelFormat),
		mLayerCount, mUsage);
		mGraphicBuffer = allocateBuffer();
		ASSERT_NE(nullptr, mGraphicBuffer);
		ASSERT_NE(nullptr, mGraphicBuffer->handle);
		ASSERT_NO_FATAL_FAILURE(fillBuffer(colors));
		ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
		ASSERT_NO_FATAL_FAILURE(fillBuffer(colors));
		}

		::android::sp<::android::GraphicBuffer> TestBufferLayer::allocateBuffer() {
		return ::android::sp<::android::GraphicBuffer>::make(
		mWidth, mHeight, static_cast<::android::PixelFormat>(mPixelFormat), mLayerCount, mUsage,
		"TestBufferLayer");
		}

		void TestBufferLayer::setDataspace(common::Dataspace dataspace, ComposerClientWriter& writer) {

graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h

+6 −3

Original line number	Diff line number	Diff line
		@@ -118,7 +118,6 @@ class TestColorLayer : public TestLayer {
		class TestBufferLayer : public TestLayer {
		public:
		TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
		const ::android::sp<::android::GraphicBuffer>& graphicBuffer,
		TestRenderEngine& renderEngine, int64_t display, uint32_t width,
		uint32_t height, common::PixelFormat format,
		Composition composition = Composition::DEVICE);
		@@ -154,6 +153,9 @@ class TestBufferLayer : public TestLayer {
		PixelFormat mPixelFormat;
		uint32_t mUsage;
		::android::Rect mAccessRegion;

		private:
		::android::sp<::android::GraphicBuffer> allocateBuffer();
		};

		class ReadbackHelper {
		@@ -194,8 +196,6 @@ class ReadbackBuffer {

		void checkReadbackBuffer(const std::vector<Color>& expectedColors);

		::android::sp<::android::GraphicBuffer> allocate();

		protected:
		uint32_t mWidth;
		uint32_t mHeight;
		@@ -208,6 +208,9 @@ class ReadbackBuffer {
		std::shared_ptr<VtsComposerClient> mComposerClient;
		::android::Rect mAccessRegion;
		native_handle_t mBufferHandle;

		private:
		::android::sp<::android::GraphicBuffer> allocateBuffer();
		};

		} // namespace aidl::android::hardware::graphics::composer3::vts