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

Commit f7618ed1 authored by Marissa Wall's avatar Marissa Wall
Browse files

test-hwc2: set layer visible region 

Test: Add "#define HAVE_NO_SURFACE_FLINGER" to
          frameworks/native/libs/gui/BufferQueueCore.cpp.
      Recompile and flash.
      Run "mm" in frameworks/native/services/surfaceflinger/tests/hwc2.
      Push test-hwc2 to device.
      Run "adb root && adb shell stop".
      Run test case. Ex: "./test-hwc2"

Change-Id: I0e620fa6763d258d7875da9bf85d41c182e015d2
parent 5a240aaf

services/surfaceflinger/tests/hwc2/Hwc2Test.cpp

+67 −5
Original line number Diff line number Diff line
@@ -525,6 +525,23 @@ public: 
        }

    }



    void setLayerVisibleRegion(hwc2_display_t display, hwc2_layer_t layer,

            const hwc_region_t& visibleRegion, hwc2_error_t* outErr = nullptr)

    {

        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(

                getFunction(HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION));

        ASSERT_TRUE(pfn) << "failed to get function";



        auto err = static_cast<hwc2_error_t>(pfn(mHwc2Device, display, layer,

                visibleRegion));

        if (outErr) {

            *outErr = err;

        } else {

            ASSERT_EQ(err, HWC2_ERROR_NONE) << "failed to set layer visible"

                    " region";

        }

    }



    void setLayerZOrder(hwc2_display_t display, hwc2_layer_t layer,

            uint32_t zOrder, hwc2_error_t* outErr = nullptr)

    {
@@ -705,6 +722,9 @@ protected: 
    /* Advances a property of Hwc2TestLayer */

    using AdvanceProperty = bool (*)(Hwc2TestLayer* testLayer);



    /* Advances properties of Hwc2TestLayers */

    using AdvanceProperties = bool (*)(Hwc2TestLayers* testLayer);



    /* For each active display it cycles through each display config and tests

     * each property value. It creates a layer, sets the property and then

     * destroys the layer */
@@ -774,7 +794,7 @@ protected: 
     * TestLayerPropertiesFunction to set property values and then

     * destroys the layers */

    void setLayerProperties(Hwc2TestCoverage coverage, size_t layerCnt,

            TestLayerPropertiesFunction function)

            TestLayerPropertiesFunction function, AdvanceProperties advance)

    {

        for (auto display : mDisplays) {

            std::vector<hwc2_config_t> configs;
@@ -792,10 +812,12 @@ protected: 
                ASSERT_NO_FATAL_FAILURE(createLayers(display, &layers, layerCnt));

                Hwc2TestLayers testLayers(layers, coverage, displayArea);



                do {

                    for (auto layer : layers) {

                        EXPECT_NO_FATAL_FAILURE(function(this, display, layer,

                                &testLayers));

                    }

                } while (advance(&testLayers));



                ASSERT_NO_FATAL_FAILURE(destroyLayers(display, std::move(layers)));

            }
@@ -1052,6 +1074,13 @@ void setTransform(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 
            testLayer->getTransform(), outErr));

}



void setVisibleRegion(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{

    EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display, layer,

            testLayer->getVisibleRegion(), outErr));

}



void setZOrder(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

        Hwc2TestLayer* testLayer, hwc2_error_t* outErr)

{
@@ -1126,6 +1155,11 @@ bool advanceTransform(Hwc2TestLayer* testLayer) 
    return testLayer->advanceTransform();

}



bool advanceVisibleRegions(Hwc2TestLayers* testLayers)

{

    return testLayers->advanceVisibleRegions();

}





static const std::array<hwc2_function_descriptor_t, 42> requiredFunctions = {{

    HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES,
@@ -2295,6 +2329,27 @@ TEST_F(Hwc2Test, SET_LAYER_TRANSFORM_bad_layer) 
            setTransform));

}



/* TESTCASE: Tests that the HWC2 can set the visible region of a layer. */

TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION)

{

    ASSERT_NO_FATAL_FAILURE(setLayerProperties(Hwc2TestCoverage::Basic, 5,

            [] (Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer,

                    Hwc2TestLayers* testLayers) {



                EXPECT_NO_FATAL_FAILURE(test->setLayerVisibleRegion(display,

                        layer, testLayers->getVisibleRegion(layer)));

            },



            advanceVisibleRegions));

}



/* TESTCASE: Tests that the HWC2 cannot set the visible region of a bad layer. */

TEST_F(Hwc2Test, SET_LAYER_VISIBLE_REGION_bad_layer)

{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,

            setVisibleRegion));

}



/* TESTCASE: Tests that the HWC2 can set the z order of a layer. */

TEST_F(Hwc2Test, SET_LAYER_Z_ORDER)

{
@@ -2304,6 +2359,13 @@ TEST_F(Hwc2Test, SET_LAYER_Z_ORDER) 


                EXPECT_NO_FATAL_FAILURE(test->setLayerZOrder(display, layer,

                        testLayers->getZOrder(layer)));

            },



            /* TestLayer z orders are set during the construction of TestLayers

             * and cannot be updated. There is no need (or ability) to cycle

             * through additional z order configurations. */

            [] (Hwc2TestLayers* /*testLayers*/) {

                return false;

            }

    ));

}

services/surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp

+32 −4
Original line number Diff line number Diff line
@@ -18,8 +18,7 @@ 


#include "Hwc2TestLayer.h"



Hwc2TestLayer::Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea,

        uint32_t zOrder)

Hwc2TestLayer::Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea)

    : mBlendMode(coverage),

      mBufferArea(coverage, displayArea),

      mColor(coverage),
@@ -29,8 +28,7 @@ Hwc2TestLayer::Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea, 
      mPlaneAlpha(coverage),

      mSourceCrop(coverage),

      mSurfaceDamage(coverage),

      mTransform(coverage),

      mZOrder(zOrder)

      mTransform(coverage)

{

    mBufferArea.setDependent(&mBuffer);

    mBufferArea.setDependent(&mSourceCrop);
@@ -48,6 +46,7 @@ std::string Hwc2TestLayer::dump() const 
        dmp << property->dump();

    }



    dmp << mVisibleRegion.dump();

    dmp << "\tz order: " << mZOrder << "\n";



    return dmp.str();
@@ -62,8 +61,20 @@ int Hwc2TestLayer::getBuffer(buffer_handle_t* outHandle, 
    return ret;

}



void Hwc2TestLayer::setZOrder(uint32_t zOrder)

{

    mZOrder = zOrder;

}



void Hwc2TestLayer::setVisibleRegion(const android::Region& region)

{

    return mVisibleRegion.set(region);

}



void Hwc2TestLayer::reset()

{

    mVisibleRegion.release();



    for (auto property : mProperties) {

        property->reset();

    }
@@ -74,6 +85,11 @@ hwc2_blend_mode_t Hwc2TestLayer::getBlendMode() const 
    return mBlendMode.get();

}



Area Hwc2TestLayer::getBufferArea() const

{

    return mBufferArea.get();

}



hwc_color_t Hwc2TestLayer::getColor() const

{

    return mColor.get();
@@ -120,6 +136,11 @@ hwc_transform_t Hwc2TestLayer::getTransform() const 
    return mTransform.get();

}



hwc_region_t Hwc2TestLayer::getVisibleRegion() const

{

    return mVisibleRegion.get();

}



uint32_t Hwc2TestLayer::getZOrder() const

{

    return mZOrder;
@@ -179,3 +200,10 @@ bool Hwc2TestLayer::advanceTransform() 
{

    return mTransform.advance();

}



bool Hwc2TestLayer::advanceVisibleRegion()

{

    if (mPlaneAlpha.advance())

        return true;

    return mDisplayFrame.advance();

}

services/surfaceflinger/tests/hwc2/Hwc2TestLayer.h

+12 −6
Original line number Diff line number Diff line
@@ -30,17 +30,20 @@ 


class Hwc2TestLayer {

public:

    Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea,

            uint32_t zOrder = 0);

    Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea);



    std::string dump() const;



    int getBuffer(buffer_handle_t* outHandle,

            android::base::unique_fd* outAcquireFence);



    void setZOrder(uint32_t zOrder);

    void setVisibleRegion(const android::Region& region);



    void reset();



    hwc2_blend_mode_t      getBlendMode() const;

    Area                   getBufferArea() const;

    hwc_color_t            getColor() const;

    hwc2_composition_t     getComposition() const;

    hwc_rect_t             getCursorPosition() const;
@@ -50,6 +53,7 @@ public: 
    hwc_frect_t            getSourceCrop() const;

    hwc_region_t           getSurfaceDamage() const;

    hwc_transform_t        getTransform() const;

    hwc_region_t           getVisibleRegion() const;

    uint32_t               getZOrder() const;



    bool advanceBlendMode();
@@ -63,11 +67,12 @@ public: 
    bool advanceSourceCrop();

    bool advanceSurfaceDamage();

    bool advanceTransform();

    bool advanceVisibleRegion();



private:

    std::array<Hwc2TestContainer*, 9> mProperties = {{

        &mBlendMode, &mColor, &mComposition, &mDataspace, &mDisplayFrame,

        &mPlaneAlpha, &mSourceCrop, &mSurfaceDamage, &mTransform

    std::array<Hwc2TestContainer*, 10> mProperties = {{

        &mBlendMode, &mBufferArea, &mColor, &mComposition, &mDataspace,

        &mDisplayFrame, &mPlaneAlpha, &mSourceCrop, &mSurfaceDamage, &mTransform

    }};



    Hwc2TestBuffer mBuffer;
@@ -82,8 +87,9 @@ private: 
    Hwc2TestSourceCrop mSourceCrop;

    Hwc2TestSurfaceDamage mSurfaceDamage;

    Hwc2TestTransform mTransform;

    Hwc2TestVisibleRegion mVisibleRegion;



    uint32_t mZOrder;

    uint32_t mZOrder = UINT32_MAX;

};



#endif /* ifndef _HWC2_TEST_LAYER_H */

services/surfaceflinger/tests/hwc2/Hwc2TestLayers.cpp

+62 −3
Original line number Diff line number Diff line
@@ -21,13 +21,22 @@ 
Hwc2TestLayers::Hwc2TestLayers(const std::vector<hwc2_layer_t>& layers,

        Hwc2TestCoverage coverage, const Area& displayArea)

{

    uint32_t nextZOrder = 0;



    for (auto layer : layers) {

        mTestLayers.emplace(std::piecewise_construct,

                std::forward_as_tuple(layer),

                std::forward_as_tuple(coverage, displayArea, nextZOrder++));

                std::forward_as_tuple(coverage, displayArea));

    }



    /* Iterate over the layers in order and assign z orders in the same order.

     * This allows us to iterate over z orders in the same way when computing

     * visible regions */

    uint32_t nextZOrder = layers.size();



    for (auto& testLayer : mTestLayers) {

        testLayer.second.setZOrder(nextZOrder--);

    }



    setVisibleRegions();

}



std::string Hwc2TestLayers::dump() const
@@ -44,6 +53,28 @@ void Hwc2TestLayers::reset() 
    for (auto& testLayer : mTestLayers) {

        testLayer.second.reset();

    }



    setVisibleRegions();

}



bool Hwc2TestLayers::advanceVisibleRegions()

{

    for (auto& testLayer : mTestLayers) {

        if (testLayer.second.advanceVisibleRegion()) {

            setVisibleRegions();

            return true;

        }

        testLayer.second.reset();

    }

    return false;

}



hwc_region_t Hwc2TestLayers::getVisibleRegion(hwc2_layer_t layer) const

{

    if (mTestLayers.count(layer) == 0) {

        []() { GTEST_FAIL(); }();

    }

    return mTestLayers.at(layer).getVisibleRegion();

}



uint32_t Hwc2TestLayers::getZOrder(hwc2_layer_t layer) const
@@ -53,3 +84,31 @@ uint32_t Hwc2TestLayers::getZOrder(hwc2_layer_t layer) const 
    }

    return mTestLayers.at(layer).getZOrder();

}



void Hwc2TestLayers::setVisibleRegions()

{

    /* The region of the display that is covered by layers above the current

     * layer */

    android::Region aboveOpaqueLayers;



    /* Iterate over test layers from max z order to min z order. */

    for (auto& testLayer : mTestLayers) {

        android::Region visibleRegion;



        /* Set the visible region of this layer */

        const hwc_rect_t displayFrame = testLayer.second.getDisplayFrame();



        visibleRegion.set(android::Rect(displayFrame.left, displayFrame.top,

                displayFrame.right, displayFrame.bottom));



        /* Remove the area covered by opaque layers above this layer

         * from this layer's visible region */

        visibleRegion.subtractSelf(aboveOpaqueLayers);



        testLayer.second.setVisibleRegion(visibleRegion);



        /* If this layer is opaque, store the region it covers */

        if (testLayer.second.getPlaneAlpha() == 1.0f)

            aboveOpaqueLayers.orSelf(visibleRegion);

    }

}

services/surfaceflinger/tests/hwc2/Hwc2TestLayers.h

+6 −1
Original line number Diff line number Diff line
@@ -37,9 +37,14 @@ public: 


    void reset();



    bool advanceVisibleRegions();



    hwc_region_t    getVisibleRegion(hwc2_layer_t layer) const;

    uint32_t        getZOrder(hwc2_layer_t layer) const;



private:

    void setVisibleRegions();



    std::map<hwc2_layer_t, Hwc2TestLayer> mTestLayers;

};