From ee24278db26505369c0e917d2a83e7e9fda36e4c Mon Sep 17 00:00:00 2001 From: Marissa Wall Date: Thu, 15 Dec 2016 12:30:12 -0800 Subject: [PATCH] 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 --- services/surfaceflinger/tests/hwc2/Hwc2Test.cpp | 82 +++++++++++++++++++++ .../surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp | 12 +++ services/surfaceflinger/tests/hwc2/Hwc2TestLayer.h | 9 ++- .../tests/hwc2/Hwc2TestProperties.cpp | 86 ++++++++++++++++++++++ .../surfaceflinger/tests/hwc2/Hwc2TestProperties.h | 31 ++++++++ 5 files changed, 217 insertions(+), 3 deletions(-) diff --git a/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp b/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp index b060be90bd..bba97b8991 100644 --- a/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp +++ b/services/surfaceflinger/tests/hwc2/Hwc2Test.cpp @@ -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( + getFunction(HWC2_FUNCTION_SET_LAYER_COLOR)); + ASSERT_TRUE(pfn) << "failed to get function"; + + auto err = static_cast(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) { diff --git a/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp b/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp index cdf4392684..caf3987701 100644 --- a/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp +++ b/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.cpp @@ -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(); diff --git a/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.h b/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.h index 86d40cc584..f548ea6f7c 100644 --- a/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.h +++ b/services/surfaceflinger/tests/hwc2/Hwc2TestLayer.h @@ -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 mProperties = {{ - &mBlendMode, &mComposition, &mDataspace, &mDisplayFrame, &mPlaneAlpha, - &mSourceCrop, &mTransform + std::array mProperties = {{ + &mBlendMode, &mColor, &mComposition, &mDataspace, &mDisplayFrame, + &mPlaneAlpha, &mSourceCrop, &mTransform }}; Hwc2TestBlendMode mBlendMode; Hwc2TestBufferArea mBufferArea; + Hwc2TestColor mColor; Hwc2TestComposition mComposition; Hwc2TestDataspace mDataspace; Hwc2TestDisplayFrame mDisplayFrame; diff --git a/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.cpp b/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.cpp index 0073857378..1e404409b4 100644 --- a/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.cpp +++ b/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.cpp @@ -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 Hwc2TestBlendMode::mDefaultBlendModes = { HWC2_BLEND_MODE_NONE, }; @@ -109,6 +121,80 @@ const std::vector 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 Hwc2TestColor::mDefaultBaseColors = { + {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX}, +}; + +const std::vector Hwc2TestColor::mBasicBaseColors = { + {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX}, + { 0, 0, 0, 0}, +}; + +const std::vector 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) { } diff --git a/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.h b/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.h index 9df532ecb0..870f1ccad3 100644 --- a/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.h +++ b/services/surfaceflinger/tests/hwc2/Hwc2TestProperties.h @@ -123,19 +123,50 @@ protected: }; +class Hwc2TestColor; + class Hwc2TestBlendMode : public Hwc2TestProperty { public: Hwc2TestBlendMode(Hwc2TestCoverage coverage); std::string dump() const override; + void setDependent(Hwc2TestColor* color); + protected: + void updateDependents() override; + + Hwc2TestColor* mColor = nullptr; + static const std::vector mDefaultBlendModes; static const std::vector mBasicBlendModes; static const std::vector mCompleteBlendModes; }; +class Hwc2TestColor : public Hwc2TestProperty { +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 mBaseColors; + static const std::vector mDefaultBaseColors; + static const std::vector mBasicBaseColors; + static const std::vector mCompleteBaseColors; + + hwc2_blend_mode_t mBlendMode; + + std::vector mColors; +}; + + class Hwc2TestComposition : public Hwc2TestProperty { public: Hwc2TestComposition(Hwc2TestCoverage coverage); -- 2.11.0