Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0a2bee4e authored by ramindani's avatar ramindani
Browse files

Clean up the GraphicBuffer. 

HIDL tests don't have any buffer created when test execution starts and with GraphicBuffer that wasn't the case.
We only initialize the buffer when required the way gralloc implementation did.

BUG: 199413815

Test: atest VtsHalGraphicsComposer3_TargetTest
Change-Id: I3aeec5b00e30e636de2e58cf7e6ced5539ae19b6
parent b2a9e072

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