From d103cd682822807d956cfb65454085fa5817a5ba Mon Sep 17 00:00:00 2001 From: Brian Lindahl Date: Fri, 9 Dec 2022 07:26:28 -0700 Subject: [PATCH] Add VTS readback tests for buffer slot clearing Bug: 258196272 Test: atest VtsHalGraphicsComposer3_ReadbackTest Test: atest VtsHalGraphicsComposerV2_2TargetTest Change-Id: I95d24f9cf10d95e54bc228c02bedab9a8281cfd1 --- .../composer/2.2/utils/vts/ComposerVts.cpp | 24 +- .../composer/2.2/utils/vts/ReadbackVts.cpp | 165 ++++--- .../2.2/utils/vts/RenderEngineVts.cpp | 4 +- .../include/composer-vts/2.2/ComposerVts.h | 6 +- .../include/composer-vts/2.2/ReadbackVts.h | 42 +- ...VtsHalGraphicsComposerV2_2ReadbackTest.cpp | 425 ++++++++++-------- .../VtsHalGraphicsComposerV2_2TargetTest.cpp | 33 +- graphics/composer/aidl/vts/ReadbackVts.cpp | 223 +++++---- graphics/composer/aidl/vts/ReadbackVts.h | 47 +- .../composer/aidl/vts/RenderEngineVts.cpp | 13 +- .../VtsHalGraphicsComposer3_ReadbackTest.cpp | 239 +++++++--- 11 files changed, 777 insertions(+), 444 deletions(-) diff --git a/graphics/composer/2.2/utils/vts/ComposerVts.cpp b/graphics/composer/2.2/utils/vts/ComposerVts.cpp index b706596df4..a6dfcaf54b 100644 --- a/graphics/composer/2.2/utils/vts/ComposerVts.cpp +++ b/graphics/composer/2.2/utils/vts/ComposerVts.cpp @@ -126,15 +126,23 @@ void ComposerClient::setReadbackBuffer(Display display, const native_handle_t* b ASSERT_EQ(Error::NONE, error) << "failed to setReadbackBuffer"; } -void ComposerClient::getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat, - Dataspace* outDataspace) { +void ComposerClient::getRequiredReadbackBufferAttributes(Display display, + PixelFormat* outPixelFormat, + Dataspace* outDataspace) { + ASSERT_EQ(Error::NONE, getReadbackBufferAttributes(display, outPixelFormat, outDataspace)); +} + +Error ComposerClient::getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat, + Dataspace* outDataspace) { + Error error; mClient->getReadbackBufferAttributes( - display, - [&](const auto& tmpError, const auto& tmpOutPixelFormat, const auto& tmpOutDataspace) { - ASSERT_EQ(Error::NONE, tmpError) << "failed to get readback buffer attributes"; - *outPixelFormat = tmpOutPixelFormat; - *outDataspace = tmpOutDataspace; - }); + display, [&](const Error& tmpError, const PixelFormat& tmpPixelFormat, + const Dataspace& tmpDataspace) { + error = tmpError; + *outPixelFormat = tmpPixelFormat; + *outDataspace = tmpDataspace; + }); + return error; } void ComposerClient::getReadbackBufferFence(Display display, int32_t* outFence) { diff --git a/graphics/composer/2.2/utils/vts/ReadbackVts.cpp b/graphics/composer/2.2/utils/vts/ReadbackVts.cpp index a1794afeed..5dd68df3a1 100644 --- a/graphics/composer/2.2/utils/vts/ReadbackVts.cpp +++ b/graphics/composer/2.2/utils/vts/ReadbackVts.cpp @@ -19,6 +19,8 @@ #include "renderengine/ExternalTexture.h" #include "renderengine/impl/ExternalTexture.h" +using ::android::status_t; + namespace android { namespace hardware { namespace graphics { @@ -107,6 +109,40 @@ int32_t ReadbackHelper::GetBytesPerPixel(PixelFormat pixelFormat) { } } +void ReadbackHelper::fillBufferAndGetFence(const sp& graphicBuffer, + IComposerClient::Color desiredColor, int* fillFence) { + ASSERT_NE(nullptr, fillFence); + std::vector desiredColors( + static_cast(graphicBuffer->getWidth() * graphicBuffer->getHeight())); + ::android::Rect bounds = graphicBuffer->getBounds(); + fillColorsArea(desiredColors, static_cast(graphicBuffer->getWidth()), + {bounds.left, bounds.top, bounds.right, bounds.bottom}, desiredColor); + ASSERT_NO_FATAL_FAILURE(fillBufferAndGetFence(graphicBuffer, desiredColors, fillFence)); +} + +void ReadbackHelper::fillBufferAndGetFence(const sp& graphicBuffer, + const std::vector& desiredColors, + int* fillFence) { + ASSERT_TRUE(graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGB_888 || + graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGBA_8888); + void* bufData; + int32_t bytesPerPixel = -1; + int32_t bytesPerStride = -1; + status_t status = + graphicBuffer->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN, + &bufData, &bytesPerPixel, &bytesPerStride); + ASSERT_EQ(::android::OK, status); + + const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0) + ? static_cast(bytesPerStride / bytesPerPixel) + : graphicBuffer->getStride(); + ReadbackHelper::fillBuffer(graphicBuffer->getWidth(), graphicBuffer->getHeight(), stride, + bufData, static_cast(graphicBuffer->getPixelFormat()), + desiredColors); + status = graphicBuffer->unlockAsync(fillFence); + ASSERT_EQ(::android::OK, status); +} + void ReadbackHelper::fillBuffer(int32_t width, int32_t height, uint32_t stride, void* bufferData, PixelFormat pixelFormat, std::vector desiredPixelColors) { @@ -116,16 +152,16 @@ void ReadbackHelper::fillBuffer(int32_t width, int32_t height, uint32_t stride, for (int row = 0; row < height; row++) { for (int col = 0; col < width; col++) { int pixel = row * width + col; - IComposerClient::Color srcColor = desiredPixelColors[pixel]; + IComposerClient::Color desiredColor = desiredPixelColors[pixel]; int offset = (row * stride + col) * bytesPerPixel; uint8_t* pixelColor = (uint8_t*)bufferData + offset; - pixelColor[0] = srcColor.r; - pixelColor[1] = srcColor.g; - pixelColor[2] = srcColor.b; + pixelColor[0] = desiredColor.r; + pixelColor[1] = desiredColor.g; + pixelColor[2] = desiredColor.b; if (bytesPerPixel == 4) { - pixelColor[3] = srcColor.a; + pixelColor[3] = desiredColor.a; } } } @@ -152,12 +188,14 @@ void ReadbackHelper::fillColorsArea(std::vector& expecte } } -bool ReadbackHelper::readbackSupported(const PixelFormat& pixelFormat, const Dataspace& dataspace, - const Error error) { +bool ReadbackHelper::readbackSupported(PixelFormat pixelFormat, Dataspace dataspace, Error error) { if (error != Error::NONE) { return false; } - // TODO: add support for RGBA_1010102 + return readbackSupported(pixelFormat, dataspace); +} + +bool ReadbackHelper::readbackSupported(PixelFormat pixelFormat, Dataspace dataspace) { if (pixelFormat != PixelFormat::RGB_888 && pixelFormat != PixelFormat::RGBA_8888) { return false; } @@ -167,71 +205,94 @@ bool ReadbackHelper::readbackSupported(const PixelFormat& pixelFormat, const Dat return true; } -void ReadbackHelper::compareColorBuffers(std::vector& expectedColors, - void* bufferData, const uint32_t stride, - const uint32_t width, const uint32_t height, - const PixelFormat pixelFormat) { - const int32_t bytesPerPixel = ReadbackHelper::GetBytesPerPixel(pixelFormat); - ASSERT_NE(-1, bytesPerPixel); - for (int row = 0; row < height; row++) { - for (int col = 0; col < width; col++) { - int pixel = row * width + col; - int offset = (row * stride + col) * bytesPerPixel; - uint8_t* pixelColor = (uint8_t*)bufferData + offset; +void ReadbackHelper::createReadbackBuffer(uint32_t width, uint32_t height, PixelFormat pixelFormat, + Dataspace dataspace, sp* graphicBuffer) { + ASSERT_NE(nullptr, graphicBuffer); + if (!readbackSupported(pixelFormat, dataspace)) { + *graphicBuffer = nullptr; + } + android::PixelFormat bufferFormat = static_cast(pixelFormat); + uint32_t layerCount = 1; + uint64_t usage = static_cast(static_cast(BufferUsage::CPU_READ_OFTEN) | + static_cast(BufferUsage::GPU_TEXTURE)); + *graphicBuffer = sp::make(width, height, bufferFormat, layerCount, usage, + "ReadbackBuffer"); + ASSERT_NE(nullptr, *graphicBuffer); + ASSERT_EQ(::android::OK, (*graphicBuffer)->initCheck()); +} - ASSERT_EQ(expectedColors[pixel].r, pixelColor[0]); - ASSERT_EQ(expectedColors[pixel].g, pixelColor[1]); - ASSERT_EQ(expectedColors[pixel].b, pixelColor[2]); +void ReadbackHelper::compareColorToBuffer(IComposerClient::Color expectedColor, + const sp& graphicBuffer, int32_t fence) { + std::vector expectedColors( + static_cast(graphicBuffer->getWidth() * graphicBuffer->getHeight())); + ::android::Rect bounds = graphicBuffer->getBounds(); + fillColorsArea(expectedColors, static_cast(graphicBuffer->getWidth()), + {bounds.left, bounds.top, bounds.right, bounds.bottom}, expectedColor); + compareColorsToBuffer(expectedColors, graphicBuffer, fence); +} + +void ReadbackHelper::compareColorsToBuffer(std::vector& expectedColors, + const sp& graphicBuffer, int32_t fence) { + ASSERT_TRUE(graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGB_888 || + graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGBA_8888); + + int bytesPerPixel = -1; + int bytesPerStride = -1; + void* bufData = nullptr; + status_t status = graphicBuffer->lockAsync(GRALLOC_USAGE_SW_READ_OFTEN, &bufData, fence, + &bytesPerPixel, &bytesPerStride); + ASSERT_EQ(::android::OK, status); + + const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0) + ? static_cast(bytesPerStride / bytesPerPixel) + : graphicBuffer->getStride(); + + if (bytesPerPixel == -1) { + PixelFormat pixelFormat = static_cast(graphicBuffer->getPixelFormat()); + bytesPerPixel = ReadbackHelper::GetBytesPerPixel(pixelFormat); + } + ASSERT_NE(-1, bytesPerPixel); + for (int row = 0; row < graphicBuffer->getHeight(); row++) { + for (int col = 0; col < graphicBuffer->getWidth(); col++) { + int pixel = row * static_cast(graphicBuffer->getWidth()) + col; + int offset = (row * static_cast(stride) + col) * bytesPerPixel; + uint8_t* pixelColor = (uint8_t*)bufData + offset; + const IComposerClient::Color expectedColor = expectedColors[static_cast(pixel)]; + ASSERT_EQ(std::round(255.0f * expectedColor.r), pixelColor[0]); + ASSERT_EQ(std::round(255.0f * expectedColor.g), pixelColor[1]); + ASSERT_EQ(std::round(255.0f * expectedColor.b), pixelColor[2]); } } + + status = graphicBuffer->unlock(); + ASSERT_EQ(::android::OK, status); } ReadbackBuffer::ReadbackBuffer(Display display, const std::shared_ptr& client, - const std::shared_ptr& gralloc, uint32_t width, - uint32_t height, PixelFormat pixelFormat, Dataspace dataspace) { + uint32_t width, uint32_t height, PixelFormat pixelFormat) { mDisplay = display; - mComposerClient = client; - mGralloc = gralloc; - - mPixelFormat = pixelFormat; - mDataspace = dataspace; - mWidth = width; mHeight = height; + mPixelFormat = pixelFormat; mLayerCount = 1; - mFormat = mPixelFormat; mUsage = static_cast(BufferUsage::CPU_READ_OFTEN | BufferUsage::GPU_TEXTURE); - - mAccessRegion.top = 0; - mAccessRegion.left = 0; - mAccessRegion.width = width; - mAccessRegion.height = height; } void ReadbackBuffer::setReadbackBuffer() { - mBufferHandle.reset(new Gralloc::NativeHandleWrapper( - mGralloc->allocate(mWidth, mHeight, mLayerCount, mFormat, mUsage, - /*import*/ true, &mStride))); - ASSERT_NE(false, mGralloc->validateBufferSize(mBufferHandle->get(), mWidth, mHeight, - mLayerCount, mFormat, mUsage, mStride)); - ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer(mDisplay, mBufferHandle->get(), -1)); + mGraphicBuffer = sp::make(mWidth, mHeight, + static_cast<::android::PixelFormat>(mPixelFormat), + mLayerCount, mUsage, "ReadbackBuffer"); + ASSERT_NE(nullptr, mGraphicBuffer); + ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck()); + mComposerClient->setReadbackBuffer(mDisplay, mGraphicBuffer->handle, -1 /* fence */); } void ReadbackBuffer::checkReadbackBuffer(std::vector expectedColors) { // lock buffer for reading int32_t fenceHandle; ASSERT_NO_FATAL_FAILURE(mComposerClient->getReadbackBufferFence(mDisplay, &fenceHandle)); - - void* bufData = mGralloc->lock(mBufferHandle->get(), mUsage, mAccessRegion, fenceHandle); - ASSERT_TRUE(mPixelFormat == PixelFormat::RGB_888 || mPixelFormat == PixelFormat::RGBA_8888); - ReadbackHelper::compareColorBuffers(expectedColors, bufData, mStride, mWidth, mHeight, - mPixelFormat); - int32_t unlockFence = mGralloc->unlock(mBufferHandle->get()); - if (unlockFence != -1) { - sync_wait(unlockFence, -1); - close(unlockFence); - } + ReadbackHelper::compareColorsToBuffer(expectedColors, mGraphicBuffer, fenceHandle); } void TestColorLayer::write(const std::shared_ptr& writer) { diff --git a/graphics/composer/2.2/utils/vts/RenderEngineVts.cpp b/graphics/composer/2.2/utils/vts/RenderEngineVts.cpp index 1700b2ade9..254ff3be57 100644 --- a/graphics/composer/2.2/utils/vts/RenderEngineVts.cpp +++ b/graphics/composer/2.2/utils/vts/RenderEngineVts.cpp @@ -83,9 +83,7 @@ void TestRenderEngine::drawLayers() { void TestRenderEngine::checkColorBuffer(std::vector& expectedColors) { void* bufferData; ASSERT_EQ(0, mGraphicBuffer->lock(mGraphicBuffer->getUsage(), &bufferData)); - ReadbackHelper::compareColorBuffers(expectedColors, bufferData, mGraphicBuffer->getStride(), - mGraphicBuffer->getWidth(), mGraphicBuffer->getHeight(), - mFormat); + ReadbackHelper::compareColorsToBuffer(expectedColors, mGraphicBuffer, -1 /* fence */); ASSERT_EQ(0, mGraphicBuffer->unlock()); } diff --git a/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ComposerVts.h b/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ComposerVts.h index 02d7bdb9da..bbf8ef3b09 100644 --- a/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ComposerVts.h +++ b/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ComposerVts.h @@ -78,8 +78,10 @@ class ComposerClient : public V2_1::vts::ComposerClient { PixelFormat format, Dataspace dataspace); void setPowerMode_2_2(Display display, IComposerClient::PowerMode mode); void setReadbackBuffer(Display display, const native_handle_t* buffer, int32_t releaseFence); - void getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat, - Dataspace* outDataspace); + void getRequiredReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat, + Dataspace* outDataspace); + Error getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat, + Dataspace* outDataspace); void getReadbackBufferFence(Display display, int32_t* outFence); std::vector getColorModes(Display display); diff --git a/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ReadbackVts.h b/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ReadbackVts.h index 58efde9b5a..7100297ac2 100644 --- a/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ReadbackVts.h +++ b/graphics/composer/2.2/utils/vts/include/composer-vts/2.2/ReadbackVts.h @@ -34,6 +34,8 @@ namespace composer { namespace V2_2 { namespace vts { +using android::GraphicBuffer; +using android::sp; using android::hardware::hidl_handle; using common::V1_1::BufferUsage; using common::V1_1::Dataspace; @@ -156,6 +158,13 @@ class ReadbackHelper { static int32_t GetBytesPerPixel(PixelFormat pixelFormat); + static void fillBufferAndGetFence(const sp& graphicBuffer, + IComposerClient::Color desiredColor, int* fillFence); + + static void fillBufferAndGetFence(const sp& graphicBuffer, + const std::vector& desiredColors, + int* fillFence); + static void fillBuffer(int32_t width, int32_t height, uint32_t stride, void* bufferData, PixelFormat pixelFormat, std::vector desiredPixelColors); @@ -166,40 +175,39 @@ class ReadbackHelper { static void fillColorsArea(std::vector& expectedColors, int32_t stride, IComposerClient::Rect area, IComposerClient::Color color); - static bool readbackSupported(const PixelFormat& pixelFormat, const Dataspace& dataspace, - const Error error); - static const std::vector colorModes; static const std::vector dataspaces; - static void compareColorBuffers(std::vector& expectedColors, - void* bufferData, const uint32_t stride, const uint32_t width, - const uint32_t height, const PixelFormat pixelFormat); + static bool readbackSupported(PixelFormat pixelFormat, Dataspace dataspace, Error error); + static bool readbackSupported(PixelFormat pixelFormat, Dataspace dataspace); + + static void createReadbackBuffer(uint32_t width, uint32_t height, PixelFormat pixelFormat, + Dataspace dataspace, sp* graphicBuffer); + + static void compareColorToBuffer(IComposerClient::Color expectedColors, + const sp& graphicBuffer, int32_t fence); + + static void compareColorsToBuffer(std::vector& expectedColors, + const sp& graphicBuffer, int32_t fence); }; class ReadbackBuffer { public: - ReadbackBuffer(Display display, const std::shared_ptr& client, - const std::shared_ptr& gralloc, uint32_t width, uint32_t height, - PixelFormat pixelFormat, Dataspace dataspace); + ReadbackBuffer(Display display, const std::shared_ptr& client, uint32_t width, + uint32_t height, PixelFormat pixelFormat); void setReadbackBuffer(); void checkReadbackBuffer(std::vector expectedColors); protected: + sp mGraphicBuffer; uint32_t mWidth; uint32_t mHeight; - uint32_t mLayerCount; - PixelFormat mFormat; - uint64_t mUsage; - AccessRegion mAccessRegion; - uint32_t mStride; - std::unique_ptr mBufferHandle = nullptr; PixelFormat mPixelFormat; - Dataspace mDataspace; + uint32_t mLayerCount; + uint64_t mUsage; Display mDisplay; - std::shared_ptr mGralloc; std::shared_ptr mComposerClient; }; diff --git a/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2ReadbackTest.cpp b/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2ReadbackTest.cpp index e2a0f4d22f..5b8ce3f943 100644 --- a/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2ReadbackTest.cpp +++ b/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2ReadbackTest.cpp @@ -40,7 +40,6 @@ namespace vts { namespace { using android::Rect; -using common::V1_1::BufferUsage; using common::V1_1::Dataspace; using common::V1_1::PixelFormat; using V2_1::Config; @@ -100,8 +99,8 @@ class GraphicsCompositionTestBase : public ::testing::Test { mTestRenderEngine->initGraphicBuffer( static_cast(mDisplayWidth), static_cast(mDisplayHeight), 1, - static_cast(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN | - BufferUsage::GPU_RENDER_TARGET)); + GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN | + GRALLOC_USAGE_HW_RENDER); mTestRenderEngine->setDisplaySettings(clientCompositionDisplay); } @@ -116,6 +115,22 @@ class GraphicsCompositionTestBase : public ::testing::Test { } } + sp allocateBuffer(uint32_t width, uint32_t height, uint32_t usage) { + const auto& graphicBuffer = sp::make( + width, height, android::PIXEL_FORMAT_RGBA_8888, + /*layerCount*/ 1u, usage, "VtsHalGraphicsComposer2_2_ReadbackTest"); + + if (graphicBuffer && android::OK == graphicBuffer->initCheck()) { + return nullptr; + } + return graphicBuffer; + } + + sp allocateBuffer(uint32_t usage) { + return allocateBuffer(static_cast(mDisplayWidth), + static_cast(mDisplayHeight), usage); + } + void clearCommandReaderState() { mReader->mCompositionChanges.clear(); mReader->mErrors.clear(); @@ -193,15 +208,9 @@ TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -220,8 +229,8 @@ TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) { std::vector expectedColors(mDisplayWidth * mDisplayHeight); ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, coloredSquare, BLUE); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); @@ -255,15 +264,9 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -272,8 +275,8 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) { mWriter->selectDisplay(mPrimaryDisplay); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); std::vector expectedColors(mDisplayWidth * mDisplayHeight); ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, @@ -319,6 +322,155 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) { } } +TEST_P(GraphicsCompositionTest, SetLayerBufferWithSlotsToClear) { + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + if (error == Error::UNSUPPORTED) { + GTEST_SUCCEED() << "Readback is unsupported"; + return; + } + ASSERT_EQ(Error::NONE, error); + + sp readbackBuffer; + ASSERT_NO_FATAL_FAILURE(ReadbackHelper::createReadbackBuffer( + mDisplayWidth, mDisplayHeight, mPixelFormat, mDataspace, &readbackBuffer)); + if (readbackBuffer == nullptr) { + GTEST_SUCCEED() << "Unsupported readback buffer attributes"; + return; + } + // no fence needed for the readback buffer + int noFence = -1; + + sp clearSlotBuffer = allocateBuffer(1u, 1u, GRALLOC_USAGE_HW_COMPOSER); + ASSERT_NE(nullptr, clearSlotBuffer); + + // red buffer + uint32_t usage = GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN; + sp redBuffer = allocateBuffer(usage); + ASSERT_NE(nullptr, redBuffer); + int redFence; + ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBufferAndGetFence(redBuffer, RED, &redFence)); + + // blue buffer + sp blueBuffer = allocateBuffer(usage); + ASSERT_NE(nullptr, blueBuffer); + int blueFence; + ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBufferAndGetFence(blueBuffer, BLUE, &blueFence)); + + // layer defaults + IComposerClient::Rect rectFullDisplay = {0, 0, mDisplayWidth, mDisplayHeight}; + Layer layer = mComposerClient->createLayer(mPrimaryDisplay, 3); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->selectLayer(layer); + mWriter->setLayerDisplayFrame(rectFullDisplay); + mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE); + + // set the layer to the blue buffer + // should be blue + { + ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer( + mPrimaryDisplay, readbackBuffer->handle, noFence)); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->selectLayer(layer); + mWriter->setLayerBuffer(/*slot*/ 0, blueBuffer->handle, blueFence); + mWriter->validateDisplay(); + execute(); + ASSERT_TRUE(mReader->mCompositionChanges.empty()); + ASSERT_TRUE(mReader->mErrors.size()); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->presentDisplay(); + execute(); + int32_t fence; + ASSERT_NO_FATAL_FAILURE(mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fence)); + ASSERT_NO_FATAL_FAILURE(ReadbackHelper::compareColorToBuffer(BLUE, readbackBuffer, fence)); + } + + // change the layer to the red buffer + // should be red + { + ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer( + mPrimaryDisplay, readbackBuffer->handle, noFence)); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->selectLayer(layer); + mWriter->setLayerBuffer(/*slot*/ 1, redBuffer->handle, redFence); + mWriter->validateDisplay(); + execute(); + ASSERT_TRUE(mReader->mCompositionChanges.empty()); + ASSERT_TRUE(mReader->mErrors.size()); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->presentDisplay(); + execute(); + int32_t fence; + ASSERT_NO_FATAL_FAILURE(mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fence)); + ReadbackHelper::compareColorToBuffer(RED, readbackBuffer, fence); + } + + // clear the slot for the blue buffer + // should still be red + { + ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer( + mPrimaryDisplay, readbackBuffer->handle, noFence)); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->selectLayer(layer); + mWriter->setLayerBuffer(/*slot*/ 0, clearSlotBuffer->handle, /*fence*/ -1); + mWriter->validateDisplay(); + execute(); + ASSERT_TRUE(mReader->mCompositionChanges.empty()); + ASSERT_TRUE(mReader->mErrors.size()); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->presentDisplay(); + execute(); + int32_t fence; + ASSERT_NO_FATAL_FAILURE(mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fence)); + ReadbackHelper::compareColorToBuffer(RED, readbackBuffer, fence); + } + + // clear the slot for the red buffer, and set the buffer with the same slot to the blue buffer + // should be blue + { + ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer( + mPrimaryDisplay, readbackBuffer->handle, noFence)); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->selectLayer(layer); + mWriter->setLayerBuffer(/*slot*/ 1, clearSlotBuffer->handle, /*fence*/ -1); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->selectLayer(layer); + mWriter->setLayerBuffer(/*slot*/ 1, blueBuffer->handle, blueFence); + mWriter->validateDisplay(); + execute(); + ASSERT_TRUE(mReader->mCompositionChanges.empty()); + ASSERT_TRUE(mReader->mErrors.size()); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->presentDisplay(); + execute(); + int32_t fence; + ASSERT_NO_FATAL_FAILURE(mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fence)); + ReadbackHelper::compareColorToBuffer(BLUE, readbackBuffer, fence); + } + + // clear the slot for the now-blue buffer + // should be black (no buffer) + // TODO(b/262037933) Ensure we never clear the active buffer's slot with the placeholder buffer + // by setting the layer to the color black + { + ASSERT_NO_FATAL_FAILURE(mComposerClient->setReadbackBuffer( + mPrimaryDisplay, readbackBuffer->handle, noFence)); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->selectLayer(layer); + mWriter->setLayerBuffer(/*slot*/ 1, clearSlotBuffer->handle, /*fence*/ -1); + mWriter->validateDisplay(); + execute(); + ASSERT_TRUE(mReader->mCompositionChanges.empty()); + ASSERT_TRUE(mReader->mErrors.size()); + mWriter->selectDisplay(mPrimaryDisplay); + mWriter->presentDisplay(); + execute(); + int32_t fence; + ASSERT_NO_FATAL_FAILURE(mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fence)); + ReadbackHelper::compareColorToBuffer(BLACK, readbackBuffer, fence); + } +} + TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { for (ColorMode mode : mTestColorModes) { std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---" @@ -327,15 +479,9 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -350,8 +496,7 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { layer->write(mWriter); // This following buffer call should have no effect - uint64_t usage = - static_cast(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN); + uint32_t usage = GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN; NativeHandleWrapper bufferHandle = mGralloc->allocate(mDisplayWidth, mDisplayHeight, 1, PixelFormat::RGBA_8888, usage); mWriter->setLayerBuffer(0, bufferHandle.get(), -1); @@ -360,8 +505,8 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { std::vector expectedColors(mDisplayWidth * mDisplayHeight); ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, coloredSquare, BLUE); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mWriter->validateDisplay(); @@ -392,15 +537,11 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { 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; - }); - + PixelFormat pixelFormat; + Dataspace dataspace; + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &pixelFormat, + &dataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(pixelFormat, dataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -428,8 +569,8 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { std::vector> layers = {layer}; - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); ASSERT_EQ(0, mReader->mErrors.size()); @@ -441,9 +582,8 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { ASSERT_EQ(1, mReader->mCompositionChanges[0].second); PixelFormat clientFormat = PixelFormat::RGBA_8888; - uint64_t clientUsage = static_cast(BufferUsage::CPU_READ_OFTEN | - BufferUsage::CPU_WRITE_OFTEN | - BufferUsage::COMPOSER_CLIENT_TARGET); + uint32_t clientUsage = GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN | + GRALLOC_USAGE_HW_FB; Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode); IComposerClient::Rect damage{0, 0, mDisplayWidth, mDisplayHeight}; @@ -510,15 +650,9 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -531,8 +665,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight}, RED); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); auto deviceLayer = std::make_shared( @@ -552,9 +686,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { deviceLayer->write(mWriter); PixelFormat clientFormat = PixelFormat::RGBA_8888; - uint64_t clientUsage = - static_cast(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN | - BufferUsage::COMPOSER_CLIENT_TARGET); + uint32_t clientUsage = + GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_FB; Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode); int32_t clientWidth = mDisplayWidth; int32_t clientHeight = mDisplayHeight / 2; @@ -633,15 +766,9 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -665,8 +792,8 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) { std::vector> layers = {layer}; - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); @@ -718,15 +845,9 @@ TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -742,8 +863,8 @@ TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) { std::vector> layers = {layer}; - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); @@ -779,15 +900,9 @@ TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -819,8 +934,8 @@ TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) { // update expected colors to match crop ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, {0, 0, mDisplayWidth, mDisplayHeight}, BLUE); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); ASSERT_EQ(0, mReader->mErrors.size()); @@ -850,15 +965,9 @@ TEST_P(GraphicsCompositionTest, SetLayerZOrder) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -886,8 +995,8 @@ TEST_P(GraphicsCompositionTest, SetLayerZOrder) { ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, blueRect, BLUE); ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); @@ -1019,15 +1128,9 @@ TEST_P(GraphicsBlendModeCompositionTest, DISABLED_None) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -1043,8 +1146,8 @@ TEST_P(GraphicsBlendModeCompositionTest, DISABLED_None) { setUpLayers(IComposerClient::BlendMode::NONE); setExpectedColors(expectedColors); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(mLayers); ASSERT_EQ(0, mReader->mErrors.size()); @@ -1077,15 +1180,9 @@ TEST_P(GraphicsBlendModeCompositionTest, DISABLED_Coverage) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -1102,8 +1199,8 @@ TEST_P(GraphicsBlendModeCompositionTest, DISABLED_Coverage) { setUpLayers(IComposerClient::BlendMode::COVERAGE); setExpectedColors(expectedColors); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(mLayers); ASSERT_EQ(0, mReader->mErrors.size()); @@ -1130,15 +1227,9 @@ TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; @@ -1153,8 +1244,8 @@ TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) { setUpLayers(IComposerClient::BlendMode::PREMULTIPLIED); setExpectedColors(expectedColors); - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(mLayers); ASSERT_EQ(0, mReader->mErrors.size()); @@ -1222,22 +1313,16 @@ TEST_P(GraphicsTransformCompositionTest, FLIP_H) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; return; } - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mLayer->setTransform(Transform::FLIP_H); mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter); @@ -1277,22 +1362,16 @@ TEST_P(GraphicsTransformCompositionTest, FLIP_V) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; return; } - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mLayer->setTransform(Transform::FLIP_V); @@ -1332,22 +1411,16 @@ TEST_P(GraphicsTransformCompositionTest, ROT_180) { 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; - }); - + Error error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay, &mPixelFormat, + &mDataspace); + mHasReadbackBuffer = ReadbackHelper::readbackSupported(mPixelFormat, mDataspace, error); if (!mHasReadbackBuffer) { std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl; GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace"; return; } - ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth, - mDisplayHeight, mPixelFormat, mDataspace); + ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, + mDisplayHeight, mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mLayer->setTransform(Transform::ROT_180); diff --git a/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2TargetTest.cpp b/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2TargetTest.cpp index 7e25a2e125..f8fbb0477e 100644 --- a/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2TargetTest.cpp +++ b/graphics/composer/2.2/vts/functional/VtsHalGraphicsComposerV2_2TargetTest.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -35,7 +36,6 @@ namespace V2_2 { namespace vts { namespace { -using common::V1_0::BufferUsage; using common::V1_1::ColorMode; using common::V1_1::Dataspace; using common::V1_1::PixelFormat; @@ -65,17 +65,13 @@ class GraphicsComposerHidlTest : public ::testing::TestWithParam { mComposerClient->setVsyncEnabled(mPrimaryDisplay, false); mComposerCallback->setVsyncAllowed(false); - mComposerClient->getRaw()->getReadbackBufferAttributes( - mPrimaryDisplay, - [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) { - mHasReadbackBuffer = tmpError == Error::NONE; - if (mHasReadbackBuffer) { - mReadbackPixelFormat = tmpPixelFormat; - mReadbackDataspace = tmpDataspace; - ASSERT_LT(static_cast(0), mReadbackPixelFormat); - ASSERT_NE(Dataspace::UNKNOWN, mReadbackDataspace); - } - }); + Error error = mComposerClient->getReadbackBufferAttributes( + mPrimaryDisplay, &mReadbackPixelFormat, &mReadbackDataspace); + mHasReadbackBuffer = error == Error::NONE; + if (mHasReadbackBuffer) { + ASSERT_LT(static_cast(0), mReadbackPixelFormat); + ASSERT_NE(Dataspace::UNKNOWN, mReadbackDataspace); + } mInvalidDisplayId = GetInvalidDisplayId(); } @@ -153,10 +149,9 @@ class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest { } NativeHandleWrapper allocate() { - uint64_t usage = - static_cast(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN); return mGralloc->allocate(/*width*/ 64, /*height*/ 64, /*layerCount*/ 1, - PixelFormat::RGBA_8888, usage); + PixelFormat::RGBA_8888, + GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN); } void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); } @@ -434,9 +429,7 @@ TEST_P(GraphicsComposerHidlTest, SetReadbackBuffer) { } // BufferUsage::COMPOSER_OUTPUT is missing - uint64_t usage = - static_cast(BufferUsage::COMPOSER_OVERLAY | BufferUsage::CPU_READ_OFTEN); - + uint64_t usage = GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_SW_READ_OFTEN; std::unique_ptr gralloc; std::unique_ptr buffer; ASSERT_NO_FATAL_FAILURE(gralloc = std::make_unique()); @@ -457,9 +450,7 @@ TEST_P(GraphicsComposerHidlTest, SetReadbackBufferBadDisplay) { return; } - uint64_t usage = - static_cast(BufferUsage::COMPOSER_OVERLAY | BufferUsage::CPU_READ_OFTEN); - + uint64_t usage = GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_SW_READ_OFTEN; std::unique_ptr gralloc; std::unique_ptr buffer; ASSERT_NO_FATAL_FAILURE(gralloc = std::make_unique()); diff --git a/graphics/composer/aidl/vts/ReadbackVts.cpp b/graphics/composer/aidl/vts/ReadbackVts.cpp index abb58e25dd..b59793f8db 100644 --- a/graphics/composer/aidl/vts/ReadbackVts.cpp +++ b/graphics/composer/aidl/vts/ReadbackVts.cpp @@ -20,6 +20,8 @@ #include "renderengine/ExternalTexture.h" #include "renderengine/impl/ExternalTexture.h" +using ::android::status_t; + namespace aidl::android::hardware::graphics::composer3::vts { const std::vector ReadbackHelper::colorModes = {ColorMode::SRGB, ColorMode::DISPLAY_P3}; @@ -27,6 +29,9 @@ const std::vector ReadbackHelper::dataspaces = {common::Dataspace::SR common::Dataspace::DISPLAY_P3}; void TestLayer::write(ComposerClientWriter& writer) { + ::android::status_t status = ::android::OK; + ASSERT_EQ(::android::OK, status); + writer.setLayerDisplayFrame(mDisplay, mLayer, mDisplayFrame); writer.setLayerSourceCrop(mDisplay, mLayer, mSourceCrop); writer.setLayerZOrder(mDisplay, mLayer, mZOrder); @@ -37,6 +42,40 @@ void TestLayer::write(ComposerClientWriter& writer) { writer.setLayerBrightness(mDisplay, mLayer, mBrightness); } +bool ReadbackHelper::readbackSupported(const common::PixelFormat& pixelFormat, + const common::Dataspace& dataspace) { + // TODO: add support for RGBA_1010102 + if (pixelFormat != common::PixelFormat::RGB_888 && + pixelFormat != common::PixelFormat::RGBA_8888) { + return false; + } + if (std::find(dataspaces.begin(), dataspaces.end(), dataspace) == dataspaces.end()) { + return false; + } + return true; +} + +void ReadbackHelper::createReadbackBuffer(ReadbackBufferAttributes readbackBufferAttributes, + const VtsDisplay& display, + sp* graphicBuffer) { + ASSERT_NE(nullptr, graphicBuffer); + if (!readbackSupported(readbackBufferAttributes.format, readbackBufferAttributes.dataspace)) { + *graphicBuffer = nullptr; + } + uint64_t usage = + static_cast(static_cast(common::BufferUsage::CPU_READ_OFTEN) | + static_cast(common::BufferUsage::GPU_TEXTURE)); + + uint32_t layerCount = 1; + *graphicBuffer = sp::make( + static_cast(display.getDisplayWidth()), + static_cast(display.getDisplayHeight()), + static_cast<::android::PixelFormat>(readbackBufferAttributes.format), layerCount, usage, + "ReadbackBuffer"); + ASSERT_NE(nullptr, *graphicBuffer); + ASSERT_EQ(::android::OK, (*graphicBuffer)->initCheck()); +} + std::string ReadbackHelper::getColorModeString(ColorMode mode) { switch (mode) { case ColorMode::SRGB: @@ -103,11 +142,11 @@ LayerSettings TestLayer::toRenderEngineLayerSettings() { return layerSettings; } -int32_t ReadbackHelper::GetBytesPerPixel(common::PixelFormat pixelFormat) { +int32_t ReadbackHelper::GetBytesPerPixel(PixelFormat pixelFormat) { switch (pixelFormat) { - case common::PixelFormat::RGBA_8888: + case PixelFormat::RGBA_8888: return 4; - case common::PixelFormat::RGB_888: + case PixelFormat::RGB_888: return 3; default: return -1; @@ -116,136 +155,161 @@ int32_t ReadbackHelper::GetBytesPerPixel(common::PixelFormat pixelFormat) { void ReadbackHelper::fillBuffer(uint32_t width, uint32_t height, uint32_t stride, void* bufferData, common::PixelFormat pixelFormat, - std::vector desiredPixelColors) { + const std::vector& desiredColors) { ASSERT_TRUE(pixelFormat == common::PixelFormat::RGB_888 || pixelFormat == common::PixelFormat::RGBA_8888); int32_t bytesPerPixel = GetBytesPerPixel(pixelFormat); ASSERT_NE(-1, bytesPerPixel); for (int row = 0; row < height; row++) { for (int col = 0; col < width; col++) { - auto pixel = row * static_cast(width) + col; - Color srcColor = desiredPixelColors[static_cast(pixel)]; + int pixel = row * static_cast(width) + col; + Color desiredColor = desiredColors[static_cast(pixel)]; int offset = (row * static_cast(stride) + col) * bytesPerPixel; uint8_t* pixelColor = (uint8_t*)bufferData + offset; - pixelColor[0] = static_cast(std::round(255.0f * srcColor.r)); - pixelColor[1] = static_cast(std::round(255.0f * srcColor.g)); - pixelColor[2] = static_cast(std::round(255.0f * srcColor.b)); + pixelColor[0] = static_cast(std::round(255.0f * desiredColor.r)); + pixelColor[1] = static_cast(std::round(255.0f * desiredColor.g)); + pixelColor[2] = static_cast(std::round(255.0f * desiredColor.b)); if (bytesPerPixel == 4) { - pixelColor[3] = static_cast(std::round(255.0f * srcColor.a)); + pixelColor[3] = static_cast(std::round(255.0f * desiredColor.a)); } } } } -void ReadbackHelper::clearColors(std::vector& expectedColors, int32_t width, int32_t height, +void ReadbackHelper::clearColors(std::vector& colors, int32_t width, int32_t height, int32_t displayWidth) { for (int row = 0; row < height; row++) { for (int col = 0; col < width; col++) { int pixel = row * displayWidth + col; - expectedColors[static_cast(pixel)] = BLACK; + colors[static_cast(pixel)] = BLACK; } } } -void ReadbackHelper::fillColorsArea(std::vector& expectedColors, int32_t stride, Rect area, - Color color) { +void ReadbackHelper::fillColorsArea(std::vector& colors, int32_t stride, Rect area, + Color desiredColor) { for (int row = area.top; row < area.bottom; row++) { for (int col = area.left; col < area.right; col++) { int pixel = row * stride + col; - expectedColors[static_cast(pixel)] = color; + colors[static_cast(pixel)] = desiredColor; } } } -bool ReadbackHelper::readbackSupported(const common::PixelFormat& pixelFormat, - const common::Dataspace& dataspace) { - if (pixelFormat != common::PixelFormat::RGB_888 && - pixelFormat != common::PixelFormat::RGBA_8888) { - return false; - } - if (std::find(dataspaces.begin(), dataspaces.end(), dataspace) == dataspaces.end()) { - return false; - } - return true; +void ReadbackHelper::fillBufferAndGetFence(const sp& graphicBuffer, + Color desiredColor, int* fillFence) { + ASSERT_NE(nullptr, fillFence); + std::vector desiredColors( + static_cast(graphicBuffer->getWidth() * graphicBuffer->getHeight())); + ::android::Rect bounds = graphicBuffer->getBounds(); + fillColorsArea(desiredColors, static_cast(graphicBuffer->getWidth()), + {bounds.left, bounds.top, bounds.right, bounds.bottom}, desiredColor); + ASSERT_NO_FATAL_FAILURE(fillBufferAndGetFence(graphicBuffer, desiredColors, fillFence)); } -void ReadbackHelper::compareColorBuffers(const std::vector& expectedColors, void* bufferData, - const uint32_t stride, const uint32_t width, - const uint32_t height, common::PixelFormat pixelFormat) { - const int32_t bytesPerPixel = ReadbackHelper::GetBytesPerPixel(pixelFormat); +void ReadbackHelper::fillBufferAndGetFence(const sp& graphicBuffer, + const std::vector& desiredColors, + int* fillFence) { + ASSERT_TRUE(graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGB_888 || + graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGBA_8888); + void* bufData; + int32_t bytesPerPixel = -1; + int32_t bytesPerStride = -1; + status_t status = + graphicBuffer->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN, + &bufData, &bytesPerPixel, &bytesPerStride); + ASSERT_EQ(::android::OK, status); + + const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0) + ? static_cast(bytesPerStride / bytesPerPixel) + : graphicBuffer->getStride(); + ReadbackHelper::fillBuffer( + graphicBuffer->getWidth(), graphicBuffer->getHeight(), stride, bufData, + static_cast(graphicBuffer->getPixelFormat()), desiredColors); + status = graphicBuffer->unlockAsync(fillFence); + ASSERT_EQ(::android::OK, status); +} + +void ReadbackHelper::compareColorToBuffer(Color expectedColor, + const sp& graphicBuffer, + const ndk::ScopedFileDescriptor& fence) { + std::vector expectedColors( + static_cast(graphicBuffer->getWidth() * graphicBuffer->getHeight())); + ::android::Rect bounds = graphicBuffer->getBounds(); + fillColorsArea(expectedColors, static_cast(graphicBuffer->getWidth()), + {bounds.left, bounds.top, bounds.right, bounds.bottom}, expectedColor); + compareColorsToBuffer(expectedColors, graphicBuffer, fence); +} + +void ReadbackHelper::compareColorsToBuffer(const std::vector& expectedColors, + const sp& graphicBuffer, + const ndk::ScopedFileDescriptor& fence) { + ASSERT_TRUE(graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGB_888 || + graphicBuffer->getPixelFormat() == ::android::PIXEL_FORMAT_RGBA_8888); + + int bytesPerPixel = -1; + int bytesPerStride = -1; + void* bufData = nullptr; + status_t status = graphicBuffer->lockAsync(GRALLOC_USAGE_SW_READ_OFTEN, &bufData, + dup(fence.get()), &bytesPerPixel, &bytesPerStride); + ASSERT_EQ(::android::OK, status); + + const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0) + ? static_cast(bytesPerStride / bytesPerPixel) + : graphicBuffer->getStride(); + + if (bytesPerPixel == -1) { + bytesPerPixel = ReadbackHelper::GetBytesPerPixel( + static_cast(graphicBuffer->getPixelFormat())); + } ASSERT_NE(-1, bytesPerPixel); - for (int row = 0; row < height; row++) { - for (int col = 0; col < width; col++) { - auto pixel = row * static_cast(width) + col; + for (int row = 0; row < graphicBuffer->getHeight(); row++) { + for (int col = 0; col < graphicBuffer->getWidth(); col++) { + int pixel = row * static_cast(graphicBuffer->getWidth()) + col; int offset = (row * static_cast(stride) + col) * bytesPerPixel; - uint8_t* pixelColor = (uint8_t*)bufferData + offset; + uint8_t* pixelColor = (uint8_t*)bufData + offset; const Color expectedColor = expectedColors[static_cast(pixel)]; ASSERT_EQ(std::round(255.0f * expectedColor.r), pixelColor[0]); ASSERT_EQ(std::round(255.0f * expectedColor.g), pixelColor[1]); ASSERT_EQ(std::round(255.0f * expectedColor.b), pixelColor[2]); } } + + status = graphicBuffer->unlock(); + ASSERT_EQ(::android::OK, status); } ReadbackBuffer::ReadbackBuffer(int64_t display, const std::shared_ptr& client, - int32_t width, int32_t height, common::PixelFormat pixelFormat, - common::Dataspace dataspace) + int32_t width, int32_t height, common::PixelFormat pixelFormat) : mComposerClient(client) { mDisplay = display; - - mPixelFormat = pixelFormat; - mDataspace = dataspace; - mWidth = static_cast(width); mHeight = static_cast(height); + mPixelFormat = pixelFormat; mLayerCount = 1; mUsage = static_cast(static_cast(common::BufferUsage::CPU_READ_OFTEN) | static_cast(common::BufferUsage::GPU_TEXTURE)); - - mAccessRegion.top = 0; - mAccessRegion.left = 0; - mAccessRegion.right = static_cast(width); - mAccessRegion.bottom = static_cast(height); -} - -::android::sp<::android::GraphicBuffer> ReadbackBuffer::allocateBuffer() { - return ::android::sp<::android::GraphicBuffer>::make( - mWidth, mHeight, static_cast<::android::PixelFormat>(mPixelFormat), mLayerCount, mUsage, - "ReadbackBuffer"); } void ReadbackBuffer::setReadbackBuffer() { - mGraphicBuffer = allocateBuffer(); + mGraphicBuffer = sp::make(mWidth, mHeight, + static_cast<::android::PixelFormat>(mPixelFormat), + mLayerCount, mUsage, "ReadbackBuffer"); ASSERT_NE(nullptr, mGraphicBuffer); ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck()); - const auto& bufferHandle = mGraphicBuffer->handle; - ::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1); - EXPECT_TRUE(mComposerClient->setReadbackBuffer(mDisplay, bufferHandle, fence).isOk()); + ::ndk::ScopedFileDescriptor noFence = ::ndk::ScopedFileDescriptor(-1); + const auto& status = + mComposerClient->setReadbackBuffer(mDisplay, mGraphicBuffer->handle, noFence); + ASSERT_TRUE(status.isOk()); } void ReadbackBuffer::checkReadbackBuffer(const std::vector& expectedColors) { - ASSERT_NE(nullptr, mGraphicBuffer); // lock buffer for reading const auto& [fenceStatus, bufferFence] = mComposerClient->getReadbackBufferFence(mDisplay); - EXPECT_TRUE(fenceStatus.isOk()); - - int bytesPerPixel = -1; - int bytesPerStride = -1; - void* bufData = nullptr; - - auto status = mGraphicBuffer->lockAsync(mUsage, mAccessRegion, &bufData, dup(bufferFence.get()), - &bytesPerPixel, &bytesPerStride); - EXPECT_EQ(::android::OK, status); - ASSERT_TRUE(mPixelFormat == PixelFormat::RGB_888 || mPixelFormat == PixelFormat::RGBA_8888); - const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0) - ? static_cast(bytesPerStride / bytesPerPixel) - : mGraphicBuffer->getStride(); - ReadbackHelper::compareColorBuffers(expectedColors, bufData, stride, mWidth, mHeight, - mPixelFormat); - status = mGraphicBuffer->unlock(); - EXPECT_EQ(::android::OK, status); + ASSERT_TRUE(fenceStatus.isOk()); + ReadbackHelper::compareColorsToBuffer(expectedColors, mGraphicBuffer, bufferFence); } void TestColorLayer::write(ComposerClientWriter& writer) { @@ -323,9 +387,8 @@ void TestBufferLayer::fillBuffer(std::vector& expectedColors) { const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0) ? static_cast(bytesPerStride / bytesPerPixel) : mGraphicBuffer->getStride(); - EXPECT_EQ(::android::OK, status); - ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(mWidth, mHeight, stride, bufData, - mPixelFormat, expectedColors)); + ASSERT_EQ(::android::OK, status); + ReadbackHelper::fillBuffer(mWidth, mHeight, stride, bufData, mPixelFormat, expectedColors); const auto unlockStatus = mGraphicBuffer->unlockAsync(&mFillFence); ASSERT_EQ(::android::OK, unlockStatus); @@ -335,13 +398,13 @@ void TestBufferLayer::setBuffer(std::vector colors) { mGraphicBuffer = allocateBuffer(); ASSERT_NE(nullptr, mGraphicBuffer); ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck()); - ASSERT_NO_FATAL_FAILURE(fillBuffer(colors)); + fillBuffer(colors); } -::android::sp<::android::GraphicBuffer> TestBufferLayer::allocateBuffer() { - return ::android::sp<::android::GraphicBuffer>::make( - mWidth, mHeight, static_cast<::android::PixelFormat>(mPixelFormat), mLayerCount, mUsage, - "TestBufferLayer"); +sp TestBufferLayer::allocateBuffer() { + return sp::make(mWidth, mHeight, + static_cast<::android::PixelFormat>(mPixelFormat), mLayerCount, + mUsage, "TestBufferLayer"); } void TestBufferLayer::setDataspace(common::Dataspace dataspace, ComposerClientWriter& writer) { diff --git a/graphics/composer/aidl/vts/ReadbackVts.h b/graphics/composer/aidl/vts/ReadbackVts.h index ee9f0d58ad..ecf0d52f65 100644 --- a/graphics/composer/aidl/vts/ReadbackVts.h +++ b/graphics/composer/aidl/vts/ReadbackVts.h @@ -33,6 +33,8 @@ using ::android::renderengine::LayerSettings; using common::Dataspace; using common::PixelFormat; using IMapper2_1 = ::android::hardware::graphics::mapper::V2_1::IMapper; +using ::android::GraphicBuffer; +using ::android::sp; static const Color BLACK = {0.0f, 0.0f, 0.0f, 1.0f}; static const Color RED = {1.0f, 0.0f, 0.0f, 1.0f}; @@ -146,7 +148,7 @@ class TestBufferLayer : public TestLayer { protected: Composition mComposition; - ::android::sp<::android::GraphicBuffer> mGraphicBuffer; + sp mGraphicBuffer; TestRenderEngine& mRenderEngine; int32_t mFillFence; uint32_t mWidth; @@ -162,6 +164,11 @@ class TestBufferLayer : public TestLayer { class ReadbackHelper { public: + static bool readbackSupported(const PixelFormat& pixelFormat, const Dataspace& dataspace); + + static void createReadbackBuffer(ReadbackBufferAttributes readbackBufferAttributes, + const VtsDisplay& display, sp* graphicBuffer); + static std::string getColorModeString(ColorMode mode); static std::string getDataspaceString(Dataspace dataspace); @@ -171,28 +178,36 @@ class ReadbackHelper { static int32_t GetBytesPerPixel(PixelFormat pixelFormat); static void fillBuffer(uint32_t width, uint32_t height, uint32_t stride, void* bufferData, - PixelFormat pixelFormat, std::vector desiredPixelColors); + PixelFormat pixelFormat, const std::vector& desriedColors); - static void clearColors(std::vector& expectedColors, int32_t width, int32_t height, + static void clearColors(std::vector& colors, int32_t width, int32_t height, int32_t displayWidth); - static void fillColorsArea(std::vector& expectedColors, int32_t stride, Rect area, - Color color); + static void fillColorsArea(std::vector& colors, int32_t stride, Rect area, + Color desiredColor); - static bool readbackSupported(const PixelFormat& pixelFormat, const Dataspace& dataspace); + static void fillBufferAndGetFence(const sp& buffer, Color desiredColor, + int* fillFence); + + static void fillBufferAndGetFence(const sp& buffer, + const std::vector& desiredColors, int* fillFence); + + static void compareColorToBuffer( + Color expectedColor, const sp& graphicBuffer, + const ndk::ScopedFileDescriptor& fence = ::ndk::ScopedFileDescriptor(-1)); + + static void compareColorsToBuffer( + const std::vector& expectedColors, const sp& graphicBuffer, + const ndk::ScopedFileDescriptor& fence = ::ndk::ScopedFileDescriptor(-1)); static const std::vector colorModes; static const std::vector dataspaces; - - static void compareColorBuffers(const std::vector& expectedColors, void* bufferData, - const uint32_t stride, const uint32_t width, - const uint32_t height, PixelFormat pixelFormat); }; class ReadbackBuffer { public: ReadbackBuffer(int64_t display, const std::shared_ptr& client, int32_t width, - int32_t height, common::PixelFormat pixelFormat, common::Dataspace dataspace); + int32_t height, common::PixelFormat pixelFormat); void setReadbackBuffer(); @@ -201,18 +216,12 @@ class ReadbackBuffer { protected: uint32_t mWidth; uint32_t mHeight; + PixelFormat mPixelFormat; uint32_t mLayerCount; uint32_t mUsage; - PixelFormat mPixelFormat; - Dataspace mDataspace; int64_t mDisplay; - ::android::sp<::android::GraphicBuffer> mGraphicBuffer; + sp mGraphicBuffer; std::shared_ptr mComposerClient; - ::android::Rect mAccessRegion; - native_handle_t mBufferHandle; - - private: - ::android::sp<::android::GraphicBuffer> allocateBuffer(); }; } // namespace aidl::android::hardware::graphics::composer3::vts diff --git a/graphics/composer/aidl/vts/RenderEngineVts.cpp b/graphics/composer/aidl/vts/RenderEngineVts.cpp index 66779c8cad..b84d0d0f28 100644 --- a/graphics/composer/aidl/vts/RenderEngineVts.cpp +++ b/graphics/composer/aidl/vts/RenderEngineVts.cpp @@ -76,18 +76,7 @@ void TestRenderEngine::drawLayers() { } void TestRenderEngine::checkColorBuffer(const std::vector& expectedColors) { - void* bufferData; - int32_t bytesPerPixel = -1; - int32_t bytesPerStride = -1; - ASSERT_EQ(0, mGraphicBuffer->lock(static_cast(mGraphicBuffer->getUsage()), - &bufferData, &bytesPerPixel, &bytesPerStride)); - const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0) - ? static_cast(bytesPerStride / bytesPerPixel) - : mGraphicBuffer->getStride(); - ReadbackHelper::compareColorBuffers(expectedColors, bufferData, stride, - mGraphicBuffer->getWidth(), mGraphicBuffer->getHeight(), - mFormat); - ASSERT_EQ(::android::OK, mGraphicBuffer->unlock()); + ReadbackHelper::compareColorsToBuffer(expectedColors, mGraphicBuffer); } } // namespace aidl::android::hardware::graphics::composer3::vts diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp index 6fa33927f0..93d9693dbd 100644 --- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp +++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp @@ -18,7 +18,6 @@ #include #include -#include #include #include #include @@ -81,13 +80,11 @@ class GraphicsCompositionTestBase : public ::testing::Test { clientCompositionDisplay.physicalDisplay = Rect(getDisplayWidth(), getDisplayHeight()); clientCompositionDisplay.clip = clientCompositionDisplay.physicalDisplay; - mTestRenderEngine->initGraphicBuffer( - static_cast(getDisplayWidth()), static_cast(getDisplayHeight()), - /*layerCount*/ 1U, - static_cast( - static_cast(common::BufferUsage::CPU_READ_OFTEN) | - static_cast(common::BufferUsage::CPU_WRITE_OFTEN) | - static_cast(common::BufferUsage::GPU_RENDER_TARGET))); + mTestRenderEngine->initGraphicBuffer(static_cast(getDisplayWidth()), + static_cast(getDisplayHeight()), + /*layerCount*/ 1U, + GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_SW_READ_OFTEN | + GRALLOC_USAGE_SW_WRITE_OFTEN); mTestRenderEngine->setDisplaySettings(clientCompositionDisplay); } @@ -115,18 +112,21 @@ class GraphicsCompositionTestBase : public ::testing::Test { ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError); } - std::pair> allocateBuffer(uint32_t usage) { - const auto width = static_cast(getDisplayWidth()); - const auto height = static_cast(getDisplayHeight()); - - const auto& graphicBuffer = ::android::sp<::android::GraphicBuffer>::make( - width, height, ::android::PIXEL_FORMAT_RGBA_8888, - /*layerCount*/ 1u, usage, "VtsHalGraphicsComposer3_ReadbackTest"); + sp allocateBuffer(uint32_t width, uint32_t height, uint64_t usage) { + sp graphicBuffer = + sp::make(width, height, ::android::PIXEL_FORMAT_RGBA_8888, + /*layerCount*/ 1u, static_cast(usage), + "VtsHalGraphicsComposer3_ReadbackTest"); if (graphicBuffer && ::android::OK == graphicBuffer->initCheck()) { - return {true, graphicBuffer}; + return graphicBuffer; } - return {false, graphicBuffer}; + return nullptr; + } + + sp allocateBuffer(uint64_t usage) { + return allocateBuffer(static_cast(getDisplayWidth()), + static_cast(getDisplayHeight()), usage); } uint64_t getStableDisplayId(int64_t display) { @@ -293,7 +293,7 @@ TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) { ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); @@ -332,7 +332,7 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) { } ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); std::vector expectedColors( static_cast(getDisplayWidth() * getDisplayHeight())); @@ -378,6 +378,143 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) { } } +TEST_P(GraphicsCompositionTest, SetLayerBufferWithSlotsToClear) { + const auto& [status, readbackBufferAttributes] = + mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId()); + if (!status.isOk()) { + GTEST_SUCCEED() << "Readback not supported"; + return; + } + + sp readbackBuffer; + ASSERT_NO_FATAL_FAILURE(ReadbackHelper::createReadbackBuffer( + readbackBufferAttributes, getPrimaryDisplay(), &readbackBuffer)); + if (readbackBuffer == nullptr) { + GTEST_SUCCEED() << "Unsupported readback buffer attributes"; + return; + } + // no fence needed for the readback buffer + ScopedFileDescriptor noFence(-1); + + sp clearSlotBuffer = allocateBuffer(1u, 1u, GRALLOC_USAGE_HW_COMPOSER); + ASSERT_NE(nullptr, clearSlotBuffer); + + // red buffer + uint64_t usage = GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN; + sp redBuffer = allocateBuffer(usage); + ASSERT_NE(nullptr, redBuffer); + int redFence; + ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBufferAndGetFence(redBuffer, RED, &redFence)); + + // blue buffer + sp blueBuffer = allocateBuffer(usage); + ASSERT_NE(nullptr, blueBuffer); + int blueFence; + ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBufferAndGetFence(blueBuffer, BLUE, &blueFence)); + + // layer defaults + common::Rect rectFullDisplay = {0, 0, getDisplayWidth(), getDisplayHeight()}; + int64_t display = getPrimaryDisplayId(); + auto [layerStatus, layer] = mComposerClient->createLayer(getPrimaryDisplayId(), 3); + ASSERT_TRUE(layerStatus.isOk()); + mWriter->setLayerDisplayFrame(display, layer, rectFullDisplay); + mWriter->setLayerCompositionType(display, layer, Composition::DEVICE); + + // set the layer to the blue buffer + // should be blue + { + auto status = mComposerClient->setReadbackBuffer(display, readbackBuffer->handle, noFence); + ASSERT_TRUE(status.isOk()); + mWriter->setLayerBuffer(display, layer, /*slot*/ 0, blueBuffer->handle, blueFence); + mWriter->validateDisplay(display, ComposerClientWriter::kNoTimestamp); + execute(); + ASSERT_TRUE(mReader.takeChangedCompositionTypes(display).empty()); + ASSERT_TRUE(mReader.takeErrors().empty()); + mWriter->presentDisplay(display); + execute(); + auto [fenceStatus, fence] = mComposerClient->getReadbackBufferFence(display); + ASSERT_TRUE(fenceStatus.isOk()); + ReadbackHelper::compareColorToBuffer(BLUE, readbackBuffer, fence); + } + + // change the layer to the red buffer + // should be red + { + auto status = mComposerClient->setReadbackBuffer(display, readbackBuffer->handle, noFence); + ASSERT_TRUE(status.isOk()); + mWriter->setLayerBuffer(display, layer, /*slot*/ 1, redBuffer->handle, redFence); + mWriter->validateDisplay(display, ComposerClientWriter::kNoTimestamp); + execute(); + ASSERT_TRUE(mReader.takeChangedCompositionTypes(display).empty()); + ASSERT_TRUE(mReader.takeErrors().empty()); + mWriter->presentDisplay(display); + execute(); + auto [fenceStatus, fence] = mComposerClient->getReadbackBufferFence(display); + ASSERT_TRUE(fenceStatus.isOk()); + ReadbackHelper::compareColorToBuffer(RED, readbackBuffer, fence); + } + + // clear the slot for the blue buffer + // should still be red + { + auto status = mComposerClient->setReadbackBuffer(display, readbackBuffer->handle, noFence); + ASSERT_TRUE(status.isOk()); + mWriter->setLayerBufferWithNewCommand(display, layer, /*slot*/ 0, clearSlotBuffer->handle, + /*fence*/ -1); + mWriter->validateDisplay(display, ComposerClientWriter::kNoTimestamp); + execute(); + ASSERT_TRUE(mReader.takeChangedCompositionTypes(display).empty()); + ASSERT_TRUE(mReader.takeErrors().empty()); + mWriter->presentDisplay(display); + execute(); + auto [fenceStatus, fence] = mComposerClient->getReadbackBufferFence(display); + ASSERT_TRUE(fenceStatus.isOk()); + ReadbackHelper::compareColorToBuffer(RED, readbackBuffer, fence); + } + + // clear the slot for the red buffer, and set the buffer with the same slot to the blue buffer + // should be blue + { + auto status = mComposerClient->setReadbackBuffer(display, readbackBuffer->handle, noFence); + ASSERT_TRUE(status.isOk()); + mWriter->setLayerBufferWithNewCommand(display, layer, /*slot*/ 1, clearSlotBuffer->handle, + /*fence*/ -1); + mWriter->setLayerBuffer(display, layer, /*slot*/ 1, blueBuffer->handle, blueFence); + mWriter->validateDisplay(display, ComposerClientWriter::kNoTimestamp); + execute(); + ASSERT_TRUE(mReader.takeChangedCompositionTypes(display).empty()); + ASSERT_TRUE(mReader.takeErrors().empty()); + mWriter->presentDisplay(display); + execute(); + auto [fenceStatus, fence] = mComposerClient->getReadbackBufferFence(display); + ASSERT_TRUE(fenceStatus.isOk()); + ReadbackHelper::compareColorToBuffer(BLUE, readbackBuffer, fence); + } + + // clear the slot for the now-blue buffer + // should be black (no buffer) + // TODO(b/262037933) Ensure we never clear the active buffer's slot with the placeholder buffer + // by setting the layer to the color black + { + auto status = mComposerClient->setReadbackBuffer(display, readbackBuffer->handle, noFence); + ASSERT_TRUE(status.isOk()); + mWriter->setLayerBufferWithNewCommand(display, layer, /*slot*/ 1, clearSlotBuffer->handle, + /*fence*/ -1); + mWriter->validateDisplay(display, ComposerClientWriter::kNoTimestamp); + execute(); + if (!mReader.takeChangedCompositionTypes(display).empty()) { + GTEST_SUCCEED(); + return; + } + ASSERT_TRUE(mReader.takeErrors().empty()); + mWriter->presentDisplay(display); + execute(); + auto [fenceStatus, fence] = mComposerClient->getReadbackBufferFence(display); + ASSERT_TRUE(fenceStatus.isOk()); + ReadbackHelper::compareColorToBuffer(BLACK, readbackBuffer, fence); + } +} + TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { for (ColorMode mode : mTestColorModes) { EXPECT_TRUE(mComposerClient @@ -399,10 +536,9 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { layer->write(*mWriter); // This following buffer call should have no effect - const auto usage = static_cast(common::BufferUsage::CPU_WRITE_OFTEN) | - static_cast(common::BufferUsage::CPU_READ_OFTEN); - const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage); - ASSERT_TRUE(graphicBufferStatus); + uint64_t usage = GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN; + sp graphicBuffer = allocateBuffer(usage); + ASSERT_NE(nullptr, graphicBuffer); const auto& buffer = graphicBuffer->handle; mWriter->setLayerBuffer(getPrimaryDisplayId(), layer->getLayer(), /*slot*/ 0, buffer, /*acquireFence*/ -1); @@ -413,7 +549,7 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) { ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp); @@ -441,7 +577,7 @@ TEST_P(GraphicsCompositionTest, SetReadbackBuffer) { } ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); } @@ -454,10 +590,9 @@ TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadDisplay) { return; } - const auto usage = static_cast(common::BufferUsage::CPU_WRITE_OFTEN) | - static_cast(common::BufferUsage::CPU_READ_OFTEN); - const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage); - ASSERT_TRUE(graphicBufferStatus); + uint64_t usage = GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN; + sp graphicBuffer = allocateBuffer(usage); + ASSERT_NE(nullptr, graphicBuffer); const auto& bufferHandle = graphicBuffer->handle; ::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1); @@ -539,7 +674,7 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { std::vector> layers = {layer}; ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); ASSERT_TRUE(mReader.takeErrors().empty()); @@ -552,16 +687,14 @@ TEST_P(GraphicsCompositionTest, ClientComposition) { ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition); PixelFormat clientFormat = PixelFormat::RGBA_8888; - auto clientUsage = static_cast( - static_cast(common::BufferUsage::CPU_READ_OFTEN) | - static_cast(common::BufferUsage::CPU_WRITE_OFTEN) | - static_cast(common::BufferUsage::COMPOSER_CLIENT_TARGET)); + auto clientUsage = GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_SW_READ_OFTEN | + GRALLOC_USAGE_SW_WRITE_OFTEN; Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode); common::Rect damage{0, 0, getDisplayWidth(), getDisplayHeight()}; // create client target buffer - const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage); - ASSERT_TRUE(graphicBufferStatus); + sp graphicBuffer = allocateBuffer(clientUsage); + ASSERT_NE(nullptr, graphicBuffer); const auto& buffer = graphicBuffer->handle; void* clientBufData; const auto stride = static_cast(graphicBuffer->stride); @@ -618,7 +751,7 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, RED); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); auto deviceLayer = std::make_shared( @@ -637,10 +770,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { deviceLayer->write(*mWriter); PixelFormat clientFormat = PixelFormat::RGBA_8888; - auto clientUsage = static_cast( - static_cast(common::BufferUsage::CPU_READ_OFTEN) | - static_cast(common::BufferUsage::CPU_WRITE_OFTEN) | - static_cast(common::BufferUsage::COMPOSER_CLIENT_TARGET)); + auto clientUsage = + GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN; Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode); int32_t clientWidth = getDisplayWidth(); int32_t clientHeight = getDisplayHeight() / 2; @@ -662,8 +793,8 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { } // create client target buffer ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition); - const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage); - ASSERT_TRUE(graphicBufferStatus); + sp graphicBuffer = allocateBuffer(clientUsage); + ASSERT_NE(nullptr, graphicBuffer); const auto& buffer = graphicBuffer->handle; void* clientBufData; @@ -725,7 +856,7 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) { std::vector> layers = {layer}; ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); @@ -793,7 +924,7 @@ TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) { std::vector> layers = {layer}; ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); @@ -859,7 +990,7 @@ TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) { ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), {0, 0, getDisplayWidth(), getDisplayHeight()}, BLUE); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); ASSERT_TRUE(mReader.takeErrors().empty()); @@ -916,7 +1047,7 @@ TEST_P(GraphicsCompositionTest, SetLayerZOrder) { ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); @@ -1026,7 +1157,7 @@ TEST_P(GraphicsCompositionTest, SetLayerBrightnessDims) { ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), dimmerRedRect, DIM_RED); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(layers); @@ -1162,7 +1293,7 @@ TEST_P(GraphicsBlendModeCompositionTest, None) { setExpectedColors(expectedColors); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(mLayers); ASSERT_TRUE(mReader.takeErrors().empty()); @@ -1207,7 +1338,7 @@ TEST_P(GraphicsBlendModeCompositionTest, Coverage) { setExpectedColors(expectedColors); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(mLayers); ASSERT_TRUE(mReader.takeErrors().empty()); @@ -1247,7 +1378,7 @@ TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) { setExpectedColors(expectedColors); ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); writeLayers(mLayers); ASSERT_TRUE(mReader.takeErrors().empty()); @@ -1321,7 +1452,7 @@ TEST_P(GraphicsTransformCompositionTest, FLIP_H) { return; } ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mLayer->setTransform(Transform::FLIP_H); mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), *mWriter); @@ -1366,7 +1497,7 @@ TEST_P(GraphicsTransformCompositionTest, FLIP_V) { return; } ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mLayer->setTransform(Transform::FLIP_V); @@ -1411,7 +1542,7 @@ TEST_P(GraphicsTransformCompositionTest, ROT_180) { return; } ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(), - getDisplayHeight(), mPixelFormat, mDataspace); + getDisplayHeight(), mPixelFormat); ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer()); mLayer->setTransform(Transform::ROT_180);