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

Commit 92d1226f authored by Valerie Hau's avatar Valerie Hau
Browse files

Setting layer dataspace to match the color mode 

Bug: 135045017
Test: build, boot, VtsHalGraphicsComposerV2_2TargetTest
Change-Id: I7188c53ca92895a98da062a248f6b781202671b8
parent b97e8538

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

+6 −1
Original line number Diff line number Diff line
@@ -287,7 +287,6 @@ TestBufferLayer::~TestBufferLayer() { 
void TestBufferLayer::write(const std::shared_ptr<CommandWriterBase>& writer) {

    TestLayer::write(writer);

    writer->setLayerCompositionType(mComposition);

    writer->setLayerDataspace(Dataspace::UNKNOWN);

    writer->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, mDisplayFrame));

    if (mBufferHandle != nullptr) writer->setLayerBuffer(0, mBufferHandle, mFillFence);

}
@@ -337,6 +336,12 @@ void TestBufferLayer::setBuffer(std::vector<IComposerClient::Color> colors) { 
                                                  mFormat, mUsage, mStride));

}



void TestBufferLayer::setDataspace(Dataspace dataspace,

                                   const std::shared_ptr<CommandWriterBase>& writer) {

    writer->selectLayer(mLayer);

    writer->setLayerDataspace(dataspace);

}



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

    writer->selectLayer(mLayer);

    writer->setLayerCompositionType(IComposerClient::Composition::CLIENT);

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

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


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



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



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



    uint32_t mWidth;

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

+290 −172
Original line number Diff line number Diff line
@@ -268,6 +268,7 @@ TEST_F(GraphicsComposerReadbackTest, SetLayerBuffer) { 
                                                       PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

        ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));



        std::vector<std::shared_ptr<TestLayer>> layers = {layer};
@@ -398,6 +399,7 @@ TEST_F(GraphicsComposerReadbackTest, ClientComposition) { 
                                                       PixelFormat::RGBA_FP16);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);



        std::vector<std::shared_ptr<TestLayer>> layers = {layer};
@@ -519,6 +521,7 @@ TEST_F(GraphicsComposerReadbackTest, DeviceAndClientComposition) { 
        deviceLayer->setDisplayFrame({0, 0, static_cast<int32_t>(deviceLayer->mWidth),

                                      static_cast<int32_t>(deviceLayer->mHeight)});

        deviceLayer->setZOrder(10);

        deviceLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

        ASSERT_NO_FATAL_FAILURE(deviceLayer->setBuffer(deviceColors));

        deviceLayer->write(mWriter);
@@ -631,6 +634,7 @@ TEST_F(GraphicsComposerReadbackTest, SetLayerDamage) { 
                                                       PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

        ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));



        std::vector<std::shared_ptr<TestLayer>> layers = {layer};
@@ -775,6 +779,7 @@ TEST_F(GraphicsComposerReadbackTest, SetLayerSourceCrop) { 
                                                       PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);

        layer->setSourceCrop({0, static_cast<float>(mDisplayHeight / 2),

                              static_cast<float>(mDisplayWidth),

                              static_cast<float>(mDisplayHeight)});
@@ -894,6 +899,7 @@ class GraphicsComposerBlendModeReadbackTest : public GraphicsComposerReadbackTes 
   public:

    void SetUp() override {

        GraphicsComposerReadbackTest::SetUp();

        mTestColorModes = {ColorMode::SRGB};  // TODO: add more color mode support

        mBackgroundColor = BLACK;

        mTopLayerColor = RED;

    }
@@ -920,6 +926,7 @@ class GraphicsComposerBlendModeReadbackTest : public GraphicsComposerReadbackTes 
                                                       PixelFormat::RGBA_8888);

        layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});

        layer->setZOrder(10);

        layer->setDataspace(Dataspace::UNKNOWN, mWriter);

        ASSERT_NO_FATAL_FAILURE(layer->setBuffer(topLayerPixelColors));



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



TEST_P(GraphicsComposerBlendModeReadbackTest, None) {

    for (ColorMode mode : mTestColorModes) {

        std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"

                  << std::endl;

        mWriter->selectDisplay(mPrimaryDisplay);

        ASSERT_NO_FATAL_FAILURE(

                mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));



        mComposerClient->getRaw()->getReadbackBufferAttributes(

                mPrimaryDisplay,

                [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {

                    mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,

                                                                           tmpDataspace, tmpError);

                    mPixelFormat = tmpPixelFormat;

                    mDataspace = tmpDataspace;

                });



        if (!mHasReadbackBuffer) {

            std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;

            GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";

            return;

        }
@@ -1003,11 +1027,29 @@ TEST_P(GraphicsComposerBlendModeReadbackTest, None) { 


        ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));

    }

}



// TODO: bug 116865056: Readback returns (245, 0, 0) for layer plane

// alpha of .2, expected 10.2

TEST_P(GraphicsComposerBlendModeReadbackTest, DISABLED_Coverage) {

    for (ColorMode mode : mTestColorModes) {

        std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"

                  << std::endl;

        mWriter->selectDisplay(mPrimaryDisplay);

        ASSERT_NO_FATAL_FAILURE(

                mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));



        mComposerClient->getRaw()->getReadbackBufferAttributes(

                mPrimaryDisplay,

                [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {

                    mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,

                                                                           tmpDataspace, tmpError);

                    mPixelFormat = tmpPixelFormat;

                    mDataspace = tmpDataspace;

                });



        if (!mHasReadbackBuffer) {

            std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;

            GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";

            return;

        }
@@ -1040,13 +1082,30 @@ TEST_P(GraphicsComposerBlendModeReadbackTest, DISABLED_Coverage) { 
        ASSERT_EQ(0, mReader->mErrors.size());

        ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));

    }

}



TEST_P(GraphicsComposerBlendModeReadbackTest, Premultiplied) {

    for (ColorMode mode : mTestColorModes) {

        std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"

                  << std::endl;

        mWriter->selectDisplay(mPrimaryDisplay);

        ASSERT_NO_FATAL_FAILURE(

                mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));



        mComposerClient->getRaw()->getReadbackBufferAttributes(

                mPrimaryDisplay,

                [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {

                    mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,

                                                                           tmpDataspace, tmpError);

                    mPixelFormat = tmpPixelFormat;

                    mDataspace = tmpDataspace;

                });



        if (!mHasReadbackBuffer) {

            std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;

            GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";

            return;

        }



        mWriter->selectDisplay(mPrimaryDisplay);



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

        ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));

    }

}



INSTANTIATE_TEST_CASE_P(BlendModeTest, GraphicsComposerBlendModeReadbackTest,

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



TEST_F(GraphicsComposerTransformReadbackTest, FLIP_H) {

    for (ColorMode mode : mTestColorModes) {

        std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"

                  << std::endl;

        mWriter->selectDisplay(mPrimaryDisplay);

        ASSERT_NO_FATAL_FAILURE(

                mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));



        mComposerClient->getRaw()->getReadbackBufferAttributes(

                mPrimaryDisplay,

                [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {

                    mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,

                                                                           tmpDataspace, tmpError);

                    mPixelFormat = tmpPixelFormat;

                    mDataspace = tmpDataspace;

                });



        if (!mHasReadbackBuffer) {

            std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;

            GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";

            return;

        }
@@ -1125,6 +1202,8 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_H) { 
                                      mDisplayHeight, mPixelFormat, mDataspace);

        ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());

        mLayer->setTransform(Transform::FLIP_H);

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



        std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);

        ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,

                                       {mSideLength / 2, 0, mSideLength, mSideLength / 2}, RED);
@@ -1147,9 +1226,27 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_H) { 


        ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));

    }

}



TEST_F(GraphicsComposerTransformReadbackTest, FLIP_V) {

    for (ColorMode mode : mTestColorModes) {

        std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"

                  << std::endl;

        mWriter->selectDisplay(mPrimaryDisplay);

        ASSERT_NO_FATAL_FAILURE(

                mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));



        mComposerClient->getRaw()->getReadbackBufferAttributes(

                mPrimaryDisplay,

                [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {

                    mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,

                                                                           tmpDataspace, tmpError);

                    mPixelFormat = tmpPixelFormat;

                    mDataspace = tmpDataspace;

                });



        if (!mHasReadbackBuffer) {

            std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;

            GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";

            return;

        }
@@ -1158,6 +1255,7 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_V) { 
        ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());



        mLayer->setTransform(Transform::FLIP_V);

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



        std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);

        ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
@@ -1180,9 +1278,27 @@ TEST_F(GraphicsComposerTransformReadbackTest, FLIP_V) { 
        ASSERT_EQ(0, mReader->mErrors.size());

        ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));

    }

}



TEST_F(GraphicsComposerTransformReadbackTest, ROT_180) {

    for (ColorMode mode : mTestColorModes) {

        std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"

                  << std::endl;

        mWriter->selectDisplay(mPrimaryDisplay);

        ASSERT_NO_FATAL_FAILURE(

                mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));



        mComposerClient->getRaw()->getReadbackBufferAttributes(

                mPrimaryDisplay,

                [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {

                    mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,

                                                                           tmpDataspace, tmpError);

                    mPixelFormat = tmpPixelFormat;

                    mDataspace = tmpDataspace;

                });



        if (!mHasReadbackBuffer) {

            std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;

            GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";

            return;

        }
@@ -1191,6 +1307,7 @@ TEST_F(GraphicsComposerTransformReadbackTest, ROT_180) { 
        ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());



        mLayer->setTransform(Transform::ROT_180);

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



        std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);

        ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
@@ -1214,6 +1331,7 @@ TEST_F(GraphicsComposerTransformReadbackTest, ROT_180) { 
        ASSERT_EQ(0, mReader->mErrors.size());

        ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));

    }

}



}  // anonymous namespace

}  // namespace vts