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

Commit ee69a59d authored by Alec Mouri's avatar Alec Mouri
Browse files

Override buffer always sets blend mode and plane alpha 

This fixes a caching issue where split screen chrome blanks out the
other side of the split screen, because chrome uses an opaque layer and
is the first layer of the cached set. The opaque bit must not be
propagated to composer, since the cached buffer is allowed to blend with
other layers if there are undamaged regions. Similarly, plane alpha is
already applied when generating the override buffer, so we should not
re-apply a non-zero plane alpha.

Bug: 183480321
Test: libcompositionengine_test
Test: split screen with chrome and recent screen

Change-Id: I22ef304409f15f10435d824e5fab6d0c075d1b9a
parent 9737f323

services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

+8 −5
Original line number Diff line number Diff line
@@ -397,14 +397,17 @@ void OutputLayer::writeOutputDependentGeometryStateToHWC( 
void OutputLayer::writeOutputIndependentGeometryStateToHWC(

        HWC2::Layer* hwcLayer, const LayerFECompositionState& outputIndependentState,

        bool skipLayer) {

    if (auto error = hwcLayer->setBlendMode(outputIndependentState.blendMode);

        error != hal::Error::NONE) {

    const auto blendMode = getState().overrideInfo.buffer

            ? hardware::graphics::composer::hal::BlendMode::PREMULTIPLIED

            : outputIndependentState.blendMode;

    if (auto error = hwcLayer->setBlendMode(blendMode); error != hal::Error::NONE) {

        ALOGE("[%s] Failed to set blend mode %s: %s (%d)", getLayerFE().getDebugName(),

              toString(outputIndependentState.blendMode).c_str(), to_string(error).c_str(),

              static_cast<int32_t>(error));

              toString(blendMode).c_str(), to_string(error).c_str(), static_cast<int32_t>(error));

    }



    const float alpha = skipLayer ? 0.0f : outputIndependentState.alpha;

    const float alpha = skipLayer

            ? 0.0f

            : (getState().overrideInfo.buffer ? 1.0f : outputIndependentState.alpha);

    ALOGV("Writing alpha %f", alpha);



    if (auto error = hwcLayer->setPlaneAlpha(alpha); error != hal::Error::NONE) {

services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp

+9 −4
Original line number Diff line number Diff line
@@ -693,7 +693,10 @@ struct OutputLayerWriteStateToHWCTest : public OutputLayerTest { 
    static constexpr Hwc2::Transform kOverrideBufferTransform = static_cast<Hwc2::Transform>(0);

    static constexpr Hwc2::IComposerClient::BlendMode kBlendMode =

            static_cast<Hwc2::IComposerClient::BlendMode>(41);

    static constexpr Hwc2::IComposerClient::BlendMode kOverrideBlendMode =

            Hwc2::IComposerClient::BlendMode::PREMULTIPLIED;

    static constexpr float kAlpha = 51.f;

    static constexpr float kOverrideAlpha = 1.f;

    static constexpr ui::Dataspace kDataspace = static_cast<ui::Dataspace>(71);

    static constexpr ui::Dataspace kOverrideDataspace = static_cast<ui::Dataspace>(72);

    static constexpr int kSupportedPerFrameMetadata = 101;
@@ -767,14 +770,16 @@ struct OutputLayerWriteStateToHWCTest : public OutputLayerTest { 


    void expectGeometryCommonCalls(Rect displayFrame = kDisplayFrame,

                                   FloatRect sourceCrop = kSourceCrop,

                                   Hwc2::Transform bufferTransform = kBufferTransform) {

                                   Hwc2::Transform bufferTransform = kBufferTransform,

                                   Hwc2::IComposerClient::BlendMode blendMode = kBlendMode,

                                   float alpha = kAlpha) {

        EXPECT_CALL(*mHwcLayer, setDisplayFrame(displayFrame)).WillOnce(Return(kError));

        EXPECT_CALL(*mHwcLayer, setSourceCrop(sourceCrop)).WillOnce(Return(kError));

        EXPECT_CALL(*mHwcLayer, setZOrder(kZOrder)).WillOnce(Return(kError));

        EXPECT_CALL(*mHwcLayer, setTransform(bufferTransform)).WillOnce(Return(kError));



        EXPECT_CALL(*mHwcLayer, setBlendMode(kBlendMode)).WillOnce(Return(kError));

        EXPECT_CALL(*mHwcLayer, setPlaneAlpha(kAlpha)).WillOnce(Return(kError));

        EXPECT_CALL(*mHwcLayer, setBlendMode(blendMode)).WillOnce(Return(kError));

        EXPECT_CALL(*mHwcLayer, setPlaneAlpha(alpha)).WillOnce(Return(kError));

    }



    void expectPerFrameCommonCalls(SimulateUnsupported unsupported = SimulateUnsupported::None,
@@ -1009,7 +1014,7 @@ TEST_F(OutputLayerWriteStateToHWCTest, includesOverrideInfoIfPresent) { 
    includeOverrideInfo();



    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideDisplayFrame.toFloatRect(),

                              kOverrideBufferTransform);

                              kOverrideBufferTransform, kOverrideBlendMode, kOverrideAlpha);

    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace);

    expectSetHdrMetadataAndBufferCalls(kOverrideBuffer, kOverrideFence);

    expectSetCompositionTypeCall(Hwc2::IComposerClient::Composition::DEVICE);