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

Commit 9e16e892 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Fix dimming flicker when entering layer caching." into tm-dev

parents 1d8c5514 e8dd3562
Loading
Loading
Loading
Loading
+15 −4
Original line number Original line Diff line number Diff line
@@ -325,7 +325,8 @@ void OutputLayer::updateCompositionState(
    // For hdr content, treat the white point as the display brightness - HDR content should not be
    // For hdr content, treat the white point as the display brightness - HDR content should not be
    // boosted or dimmed.
    // boosted or dimmed.
    if (isHdrDataspace(state.dataspace) ||
    if (isHdrDataspace(state.dataspace) ||
        getOutput().getState().displayBrightnessNits == getOutput().getState().sdrWhitePointNits) {
        getOutput().getState().displayBrightnessNits == getOutput().getState().sdrWhitePointNits ||
        getOutput().getState().displayBrightnessNits == 0.f) {
        state.dimmingRatio = 1.f;
        state.dimmingRatio = 1.f;
        state.whitePointNits = getOutput().getState().displayBrightnessNits;
        state.whitePointNits = getOutput().getState().displayBrightnessNits;
    } else {
    } else {
@@ -506,9 +507,18 @@ void OutputLayer::writeOutputDependentPerFrameStateToHWC(HWC2::Layer* hwcLayer)
              to_string(error).c_str(), static_cast<int32_t>(error));
              to_string(error).c_str(), static_cast<int32_t>(error));
    }
    }


    // Don't dim cached layers
    // Cached layers are not dimmed, which means that composer should attempt to dim.
    const auto dimmingRatio =
    // Note that if the dimming ratio is large, then this may cause the cached layer
            outputDependentState.overrideInfo.buffer ? 1.f : outputDependentState.dimmingRatio;
    // to kick back into GPU composition :(
    // Also note that this assumes that there are no HDR layers that are able to be cached.
    // Otherwise, this could cause HDR layers to be dimmed twice.
    const auto dimmingRatio = outputDependentState.overrideInfo.buffer
            ? (getOutput().getState().displayBrightnessNits != 0.f
                       ? std::clamp(getOutput().getState().sdrWhitePointNits /
                                            getOutput().getState().displayBrightnessNits,
                                    0.f, 1.f)
                       : 1.f)
            : outputDependentState.dimmingRatio;


    if (auto error = hwcLayer->setBrightness(dimmingRatio); error != hal::Error::NONE) {
    if (auto error = hwcLayer->setBrightness(dimmingRatio); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set brightness %f: %s (%d)", getLayerFE().getDebugName(),
        ALOGE("[%s] Failed to set brightness %f: %s (%d)", getLayerFE().getDebugName(),
@@ -788,6 +798,7 @@ std::vector<LayerFE::LayerSettings> OutputLayer::getOverrideCompositionList() co
            }};
            }};
    settings.sourceDataspace = getState().overrideInfo.dataspace;
    settings.sourceDataspace = getState().overrideInfo.dataspace;
    settings.alpha = 1.0f;
    settings.alpha = 1.0f;
    settings.whitePointNits = getOutput().getState().sdrWhitePointNits;


    return {static_cast<LayerFE::LayerSettings>(settings)};
    return {static_cast<LayerFE::LayerSettings>(settings)};
}
}
+11 −6
Original line number Original line Diff line number Diff line
@@ -657,7 +657,7 @@ TEST_F(OutputLayerUpdateCompositionStateTest, setsOutputLayerColorspaceCorrectly
    EXPECT_EQ(ui::Dataspace::V0_SCRGB, mOutputLayer.getState().dataspace);
    EXPECT_EQ(ui::Dataspace::V0_SCRGB, mOutputLayer.getState().dataspace);
}
}


TEST_F(OutputLayerUpdateCompositionStateTest, setsWhitePointNitsCorrectly) {
TEST_F(OutputLayerUpdateCompositionStateTest, setsWhitePointNitsAndDimmingRatioCorrectly) {
    mOutputState.sdrWhitePointNits = 200.f;
    mOutputState.sdrWhitePointNits = 200.f;
    mOutputState.displayBrightnessNits = 800.f;
    mOutputState.displayBrightnessNits = 800.f;


@@ -665,12 +665,15 @@ TEST_F(OutputLayerUpdateCompositionStateTest, setsWhitePointNitsCorrectly) {
    mLayerFEState.isColorspaceAgnostic = false;
    mLayerFEState.isColorspaceAgnostic = false;
    mOutputLayer.updateCompositionState(false, false, ui::Transform::RotationFlags::ROT_0);
    mOutputLayer.updateCompositionState(false, false, ui::Transform::RotationFlags::ROT_0);
    EXPECT_EQ(mOutputState.sdrWhitePointNits, mOutputLayer.getState().whitePointNits);
    EXPECT_EQ(mOutputState.sdrWhitePointNits, mOutputLayer.getState().whitePointNits);
    EXPECT_EQ(mOutputState.sdrWhitePointNits / mOutputState.displayBrightnessNits,
              mOutputLayer.getState().dimmingRatio);


    mLayerFEState.dataspace = ui::Dataspace::BT2020_ITU_PQ;
    mLayerFEState.dataspace = ui::Dataspace::BT2020_ITU_PQ;
    mLayerFEState.isColorspaceAgnostic = false;
    mLayerFEState.isColorspaceAgnostic = false;
    mOutputLayer.updateCompositionState(false, false, ui::Transform::RotationFlags::ROT_0);
    mOutputLayer.updateCompositionState(false, false, ui::Transform::RotationFlags::ROT_0);


    EXPECT_EQ(mOutputState.displayBrightnessNits, mOutputLayer.getState().whitePointNits);
    EXPECT_EQ(mOutputState.displayBrightnessNits, mOutputLayer.getState().whitePointNits);
    EXPECT_EQ(1.f, mOutputLayer.getState().dimmingRatio);
}
}


TEST_F(OutputLayerUpdateCompositionStateTest, doesNotRecomputeGeometryIfNotRequested) {
TEST_F(OutputLayerUpdateCompositionStateTest, doesNotRecomputeGeometryIfNotRequested) {
@@ -750,9 +753,10 @@ struct OutputLayerWriteStateToHWCTest : public OutputLayerTest {
    static constexpr bool kLayerGenericMetadata1Mandatory = true;
    static constexpr bool kLayerGenericMetadata1Mandatory = true;
    static constexpr bool kLayerGenericMetadata2Mandatory = true;
    static constexpr bool kLayerGenericMetadata2Mandatory = true;
    static constexpr float kWhitePointNits = 200.f;
    static constexpr float kWhitePointNits = 200.f;
    static constexpr float kSdrWhitePointNits = 100.f;
    static constexpr float kDisplayBrightnessNits = 400.f;
    static constexpr float kDisplayBrightnessNits = 400.f;
    static constexpr float kLayerBrightness = kWhitePointNits / kDisplayBrightnessNits;
    static constexpr float kLayerBrightness = kWhitePointNits / kDisplayBrightnessNits;
    static constexpr float kFullLayerBrightness = 1.f;
    static constexpr float kOverrideLayerBrightness = kSdrWhitePointNits / kDisplayBrightnessNits;


    static const half4 kColor;
    static const half4 kColor;
    static const Rect kDisplayFrame;
    static const Rect kDisplayFrame;
@@ -798,6 +802,7 @@ struct OutputLayerWriteStateToHWCTest : public OutputLayerTest {
        mLayerFEState.acquireFence = kFence;
        mLayerFEState.acquireFence = kFence;


        mOutputState.displayBrightnessNits = kDisplayBrightnessNits;
        mOutputState.displayBrightnessNits = kDisplayBrightnessNits;
        mOutputState.sdrWhitePointNits = kSdrWhitePointNits;


        EXPECT_CALL(mOutput, getDisplayColorProfile())
        EXPECT_CALL(mOutput, getDisplayColorProfile())
                .WillRepeatedly(Return(&mDisplayColorProfile));
                .WillRepeatedly(Return(&mDisplayColorProfile));
@@ -1117,7 +1122,7 @@ TEST_F(OutputLayerWriteStateToHWCTest, overriddenSkipLayerDoesNotSendBuffer) {
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
                              kOverrideBlendMode, kSkipAlpha);
                              kOverrideBlendMode, kSkipAlpha);
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
                              kOverrideSurfaceDamage, kFullLayerBrightness);
                              kOverrideSurfaceDamage, kOverrideLayerBrightness);
    expectSetHdrMetadataAndBufferCalls();
    expectSetHdrMetadataAndBufferCalls();
    expectSetCompositionTypeCall(Composition::DEVICE);
    expectSetCompositionTypeCall(Composition::DEVICE);
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));
@@ -1133,7 +1138,7 @@ TEST_F(OutputLayerWriteStateToHWCTest, overriddenSkipLayerForSolidColorDoesNotSe
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
                              kOverrideBlendMode, kSkipAlpha);
                              kOverrideBlendMode, kSkipAlpha);
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
                              kOverrideSurfaceDamage, kFullLayerBrightness);
                              kOverrideSurfaceDamage, kOverrideLayerBrightness);
    expectSetHdrMetadataAndBufferCalls();
    expectSetHdrMetadataAndBufferCalls();
    expectSetCompositionTypeCall(Composition::DEVICE);
    expectSetCompositionTypeCall(Composition::DEVICE);
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));
@@ -1149,7 +1154,7 @@ TEST_F(OutputLayerWriteStateToHWCTest, includesOverrideInfoIfPresent) {
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
                              kOverrideBlendMode, kOverrideAlpha);
                              kOverrideBlendMode, kOverrideAlpha);
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
                              kOverrideSurfaceDamage, kFullLayerBrightness);
                              kOverrideSurfaceDamage, kOverrideLayerBrightness);
    expectSetHdrMetadataAndBufferCalls(kOverrideHwcSlot, kOverrideBuffer, kOverrideFence);
    expectSetHdrMetadataAndBufferCalls(kOverrideHwcSlot, kOverrideBuffer, kOverrideFence);
    expectSetCompositionTypeCall(Composition::DEVICE);
    expectSetCompositionTypeCall(Composition::DEVICE);
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));
@@ -1165,7 +1170,7 @@ TEST_F(OutputLayerWriteStateToHWCTest, includesOverrideInfoForSolidColorIfPresen
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
    expectGeometryCommonCalls(kOverrideDisplayFrame, kOverrideSourceCrop, kOverrideBufferTransform,
                              kOverrideBlendMode, kOverrideAlpha);
                              kOverrideBlendMode, kOverrideAlpha);
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
    expectPerFrameCommonCalls(SimulateUnsupported::None, kOverrideDataspace, kOverrideVisibleRegion,
                              kOverrideSurfaceDamage, kFullLayerBrightness);
                              kOverrideSurfaceDamage, kOverrideLayerBrightness);
    expectSetHdrMetadataAndBufferCalls(kOverrideHwcSlot, kOverrideBuffer, kOverrideFence);
    expectSetHdrMetadataAndBufferCalls(kOverrideHwcSlot, kOverrideBuffer, kOverrideFence);
    expectSetCompositionTypeCall(Composition::DEVICE);
    expectSetCompositionTypeCall(Composition::DEVICE);
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));
    EXPECT_CALL(*mLayerFE, hasRoundedCorners()).WillRepeatedly(Return(false));