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

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

test-hwc2: set layer color 

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: Ic280f91189a4d6ddd67a33901244714f3c0a46dd
parent c57468f1

services/surfaceflinger/tests/hwc2/Hwc2Test.cpp

+82 −0
Original line number Diff line number Diff line
@@ -375,6 +375,22 @@ public: 
        }

    }



    void setLayerColor(hwc2_display_t display, hwc2_layer_t layer,

            hwc_color_t color, hwc2_error_t* outErr = nullptr)

    {

        auto pfn = reinterpret_cast<HWC2_PFN_SET_LAYER_COLOR>(

                getFunction(HWC2_FUNCTION_SET_LAYER_COLOR));

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



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

                color));

        if (outErr) {

            *outErr = err;

        } else {

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

        }

    }



    void setLayerDataspace(hwc2_display_t display, hwc2_layer_t layer,

            android_dataspace_t dataspace, hwc2_error_t* outErr = nullptr)

    {
@@ -875,6 +891,19 @@ void setBlendMode(Hwc2Test* test, hwc2_display_t display, hwc2_layer_t layer, 
            testLayer.getBlendMode(), outErr));

}



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

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

{

    ASSERT_NO_FATAL_FAILURE(test->setLayerCompositionType(display,

            layer, HWC2_COMPOSITION_SOLID_COLOR));

    ASSERT_NO_FATAL_FAILURE(test->setLayerPlaneAlpha(display,

            layer, testLayer.getPlaneAlpha()));

    ASSERT_NO_FATAL_FAILURE(test->setLayerBlendMode(display,

            layer, testLayer.getBlendMode()));

    EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,

            testLayer.getColor(), outErr));

}



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

        const Hwc2TestLayer& testLayer, hwc2_error_t* outErr)

{
@@ -945,6 +974,17 @@ bool advanceBlendMode(Hwc2TestLayer* testLayer) 
    return testLayer->advanceBlendMode();

}



bool advanceColor(Hwc2TestLayer* testLayer)

{

    /* Color depends on blend mode so advance blend mode last so color is not

     * force to update as often */

    if (testLayer->advancePlaneAlpha())

        return true;

    if (testLayer->advanceColor())

        return true;

    return testLayer->advanceBlendMode();

}



bool advanceComposition(Hwc2TestLayer* testLayer)

{

    return testLayer->advanceComposition();
@@ -1859,6 +1899,48 @@ TEST_F(Hwc2Test, SET_LAYER_BLEND_MODE_bad_parameter) 
    ));

}



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

TEST_F(Hwc2Test, SET_LAYER_COLOR)

{

    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Complete,

            setColor, advanceColor));

}



/* TESTCASE: Tests that the HWC2 can update the color of a layer. */

TEST_F(Hwc2Test, SET_LAYER_COLOR_update)

{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyUpdate(Hwc2TestCoverage::Complete,

            setColor, advanceColor));

}



/* TESTCASE: Tests that the HWC2 can set the color of a layer when the

 * composition type has not been set to HWC2_COMPOSITION_SOLID_COLOR. */

TEST_F(Hwc2Test, SET_LAYER_COLOR_composition_type_unset)

{

    ASSERT_NO_FATAL_FAILURE(setLayerProperty(Hwc2TestCoverage::Basic,

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

                    const Hwc2TestLayer& testLayer, hwc2_error_t* outErr) {



                EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, layer,

                        testLayer.getColor(), outErr));

            },



            advanceColor));

}



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

TEST_F(Hwc2Test, SET_LAYER_COLOR_bad_layer)

{

    ASSERT_NO_FATAL_FAILURE(setLayerPropertyBadLayer(Hwc2TestCoverage::Default,

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

                    const Hwc2TestLayer& testLayer, hwc2_error_t* outErr) {



                EXPECT_NO_FATAL_FAILURE(test->setLayerColor(display, badLayer,

                        testLayer.getColor(), outErr));

            }

    ));

}



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

TEST_F(Hwc2Test, SET_LAYER_DATASPACE)

{

services/surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp

+12 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ Hwc2TestLayer::Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea, 
        uint32_t zOrder)

    : mBlendMode(coverage),

      mBufferArea(coverage, displayArea),

      mColor(coverage),

      mComposition(coverage),

      mDataspace(coverage),

      mDisplayFrame(coverage, displayArea),
@@ -31,6 +32,7 @@ Hwc2TestLayer::Hwc2TestLayer(Hwc2TestCoverage coverage, const Area& displayArea, 
      mZOrder(zOrder)

{

    mBufferArea.setDependent(&mSourceCrop);

    mBlendMode.setDependent(&mColor);

}



std::string Hwc2TestLayer::dump() const
@@ -60,6 +62,11 @@ hwc2_blend_mode_t Hwc2TestLayer::getBlendMode() const 
    return mBlendMode.get();

}



hwc_color_t Hwc2TestLayer::getColor() const

{

    return mColor.get();

}



hwc2_composition_t Hwc2TestLayer::getComposition() const

{

    return mComposition.get();
@@ -105,6 +112,11 @@ bool Hwc2TestLayer::advanceBufferArea() 
    return mBufferArea.advance();

}



bool Hwc2TestLayer::advanceColor()

{

    return mColor.advance();

}



bool Hwc2TestLayer::advanceComposition()

{

    return mComposition.advance();

services/surfaceflinger/tests/hwc2/Hwc2TestLayer.h

+6 −3
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ public: 
    void reset();



    hwc2_blend_mode_t      getBlendMode() const;

    hwc_color_t            getColor() const;

    hwc2_composition_t     getComposition() const;

    android_dataspace_t    getDataspace() const;

    hwc_rect_t             getDisplayFrame() const;
@@ -45,6 +46,7 @@ public: 


    bool advanceBlendMode();

    bool advanceBufferArea();

    bool advanceColor();

    bool advanceComposition();

    bool advanceDataspace();

    bool advanceDisplayFrame();
@@ -53,13 +55,14 @@ public: 
    bool advanceTransform();



private:

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

        &mBlendMode, &mComposition, &mDataspace, &mDisplayFrame, &mPlaneAlpha,

        &mSourceCrop, &mTransform

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

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

        &mPlaneAlpha, &mSourceCrop, &mTransform

    }};



    Hwc2TestBlendMode mBlendMode;

    Hwc2TestBufferArea mBufferArea;

    Hwc2TestColor mColor;

    Hwc2TestComposition mComposition;

    Hwc2TestDataspace mDataspace;

    Hwc2TestDisplayFrame mDisplayFrame;

services/surfaceflinger/tests/hwc2/Hwc2TestProperties.cpp

+86 −0
Original line number Diff line number Diff line
@@ -93,6 +93,18 @@ std::string Hwc2TestBlendMode::dump() const 
    return dmp.str();

}



void Hwc2TestBlendMode::setDependent(Hwc2TestColor* color)

{

    mColor = color;

    updateDependents();

}



void Hwc2TestBlendMode::updateDependents()

{

    if (mColor)

        mColor->updateBlendMode(get());

}



const std::vector<hwc2_blend_mode_t> Hwc2TestBlendMode::mDefaultBlendModes = {

    HWC2_BLEND_MODE_NONE,

};
@@ -109,6 +121,80 @@ const std::vector<hwc2_blend_mode_t> Hwc2TestBlendMode::mCompleteBlendModes = { 
};





Hwc2TestColor::Hwc2TestColor(Hwc2TestCoverage coverage,

        hwc2_blend_mode_t blendMode)

    : Hwc2TestProperty(mColors),

      mBaseColors((coverage == Hwc2TestCoverage::Complete)? mCompleteBaseColors:

            (coverage == Hwc2TestCoverage::Basic)? mBasicBaseColors:

            mDefaultBaseColors),

      mBlendMode(blendMode)

{

    update();

}



std::string Hwc2TestColor::dump() const

{

    std::stringstream dmp;

    const hwc_color_t& color = get();

    dmp << "\tcolor: r " << std::to_string(color.r) << ", g "

            << std::to_string(color.g) << ", b " << std::to_string(color.b)

            << ", a " << std::to_string(color.a) << "\n";

    return dmp.str();

}



void Hwc2TestColor::updateBlendMode(hwc2_blend_mode_t blendMode)

{

    mBlendMode = blendMode;

    update();

}



void Hwc2TestColor::update()

{

    if (mBlendMode != HWC2_BLEND_MODE_PREMULTIPLIED) {

        mColors = mBaseColors;

        return;

    }



    mColors.clear();



    for (const hwc_color_t& baseColor : mBaseColors) {

        if (baseColor.a >= baseColor.r && baseColor.a >= baseColor.g

                && baseColor.a >= baseColor.b) {

            mColors.push_back(baseColor);

        }

    }



}



const std::vector<hwc_color_t> Hwc2TestColor::mDefaultBaseColors = {

    {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX},

};



const std::vector<hwc_color_t> Hwc2TestColor::mBasicBaseColors = {

    {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX},

    {        0,         0,         0,         0},

};



const std::vector<hwc_color_t> Hwc2TestColor::mCompleteBaseColors = {

    {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX},

    {UINT8_MAX, UINT8_MAX, UINT8_MAX,         0},

    {UINT8_MAX, UINT8_MAX,         0, UINT8_MAX},

    {UINT8_MAX, UINT8_MAX,         0,         0},

    {UINT8_MAX,         0, UINT8_MAX, UINT8_MAX},

    {UINT8_MAX,         0, UINT8_MAX,         0},

    {UINT8_MAX,         0,         0, UINT8_MAX},

    {UINT8_MAX,         0,         0,         0},

    {        0, UINT8_MAX, UINT8_MAX, UINT8_MAX},

    {        0, UINT8_MAX, UINT8_MAX,         0},

    {        0, UINT8_MAX,         0, UINT8_MAX},

    {        0, UINT8_MAX,         0,         0},

    {        0,         0, UINT8_MAX, UINT8_MAX},

    {        0,         0, UINT8_MAX,         0},

    {        0,         0,         0, UINT8_MAX},

    {        0,         0,         0,         0},

};





Hwc2TestComposition::Hwc2TestComposition(Hwc2TestCoverage coverage)

    : Hwc2TestProperty(coverage, mCompleteCompositions, mBasicCompositions,

            mDefaultCompositions) { }

services/surfaceflinger/tests/hwc2/Hwc2TestProperties.h

+31 −0
Original line number Diff line number Diff line
@@ -123,19 +123,50 @@ protected: 
};





class Hwc2TestColor;



class Hwc2TestBlendMode : public Hwc2TestProperty<hwc2_blend_mode_t> {

public:

    Hwc2TestBlendMode(Hwc2TestCoverage coverage);



    std::string dump() const override;



    void setDependent(Hwc2TestColor* color);



protected:

    void updateDependents() override;



    Hwc2TestColor* mColor = nullptr;



    static const std::vector<hwc2_blend_mode_t> mDefaultBlendModes;

    static const std::vector<hwc2_blend_mode_t> mBasicBlendModes;

    static const std::vector<hwc2_blend_mode_t> mCompleteBlendModes;

};





class Hwc2TestColor : public Hwc2TestProperty<hwc_color_t> {

public:

    Hwc2TestColor(Hwc2TestCoverage coverage,

            hwc2_blend_mode_t blendMode = HWC2_BLEND_MODE_NONE);



    std::string dump() const override;



    void updateBlendMode(hwc2_blend_mode_t blendMode);



protected:

    void update();



    std::vector<hwc_color_t> mBaseColors;

    static const std::vector<hwc_color_t> mDefaultBaseColors;

    static const std::vector<hwc_color_t> mBasicBaseColors;

    static const std::vector<hwc_color_t> mCompleteBaseColors;



    hwc2_blend_mode_t mBlendMode;



    std::vector<hwc_color_t> mColors;

};





class Hwc2TestComposition : public Hwc2TestProperty<hwc2_composition_t> {

public:

    Hwc2TestComposition(Hwc2TestCoverage coverage);