diff --git a/rosen/modules/render_service/core/pipeline/main_thread/rs_main_thread.cpp b/rosen/modules/render_service/core/pipeline/main_thread/rs_main_thread.cpp index 17bbf23766b4586d7fa5dc98712c905624543491..4da602a60d7658cb897d0142ab8b6fe931d5c3e0 100644 --- a/rosen/modules/render_service/core/pipeline/main_thread/rs_main_thread.cpp +++ b/rosen/modules/render_service/core/pipeline/main_thread/rs_main_thread.cpp @@ -1796,7 +1796,7 @@ void RSMainThread::CollectInfoForHardwareComposer() } // If hardware don't support hdr render, should disable direct composition - if (RSLuminanceControl::Get().IsCloseHardwareHdr() && + if (RSLuminanceControl::Get().IsHardwareHdrDisable() && surfaceNode->GetVideoHdrStatus() != HdrStatus::NO_HDR && !surfaceNode->GetSpecialLayerMgr().Find(SpecialLayerType::PROTECTED)) { doDirectComposition_ = false; diff --git a/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.cpp b/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.cpp index c0ae6205acae805505c4edb4916146347f2664d1..e920d81d947464396b21b5558aab94bf83041a0b 100644 --- a/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.cpp +++ b/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.cpp @@ -458,7 +458,7 @@ void RSUniRenderVisitor::HandlePixelFormat(RSScreenRenderNode& node) RSSystemProperties::GetHdrImageEnabled(), RSSystemProperties::GetHdrVideoEnabled()); ScreenId screenId = node.GetScreenId(); bool hasUniRenderHdrSurface = node.GetHasUniRenderHdrSurface(); - if ((RSLuminanceControl::Get().IsCloseHardwareHdr() && !drmNodes_.empty()) || node.GetForceCloseHdr()) { + if ((RSLuminanceControl::Get().IsHardwareHdrDisable() && !drmNodes_.empty()) || node.GetForceCloseHdr()) { // Disable hdr when drm videos exist to avoid flicker RSLuminanceControl::Get().SetHdrStatus(screenId, HdrStatus::NO_HDR); } else { @@ -475,7 +475,7 @@ void RSUniRenderVisitor::HandlePixelFormat(RSScreenRenderNode& node) RS_LOGD("HandlePixelFormat HDRService isHdrOn:%{public}d hasUniRenderHdrSurface:%{public}d " "brightnessRatio:%{public}f screenId:%{public}" PRIu64 " status:%{public}d", isHdrOn, hasUniRenderHdrSurface, brightnessRatio, screenId, node.GetDisplayHdrStatus()); - if ((!hasUniRenderHdrSurface && !RSLuminanceControl::Get().IsCloseHardwareHdr()) || node.GetForceCloseHdr()) { + if (!hasUniRenderHdrSurface && !RSLuminanceControl::Get().IsHardwareHdrDisable()) { isHdrOn = false; } node.SetHDRPresent(isHdrOn); @@ -2232,9 +2232,7 @@ void RSUniRenderVisitor::UpdateHwcNodeDirtyRegionAndCreateLayer(std::shared_ptr< } continue; } - if (((curScreenNode_->GetHasUniRenderHdrSurface() && !RSHdrUtil::GetRGBA1010108Enabled()) || - !drmNodes_.empty() || hasFingerprint_) && - !hwcNodePtr->GetSpecialLayerMgr().Find(SpecialLayerType::PROTECTED)) { + if (IsHwcNodeHardwareForcedDisabled(curScreenNode_->GetHasUniRenderHdrSurface(), hwcNodePtr)) { RS_OPTIONAL_TRACE_FMT("hwc debug: name:%s id:%" PRIu64 " disabled by Having UniRenderHdrSurface/DRM node", node->GetName().c_str(), node->GetId()); @@ -2263,6 +2261,19 @@ void RSUniRenderVisitor::UpdateHwcNodeDirtyRegionAndCreateLayer(std::shared_ptr< } } +bool RSUniRenderVisitor::IsHwcNodeHardwareForcedDisabled(bool hasUniRenderHdrSurface, + const std::shared_ptr& hwcNodePtr) const +{ + if (hwcNodePtr == nullptr || hwcNodePtr->GetSpecialLayerMgr().Find(SpecialLayerType::PROTECTED)) { + return false; + } + bool isHdrHardwareDisabled = (RSHdrUtil::CheckIsHdrSurface(*hwcNodePtr) != HdrStatus::NO_HDR || + RSLuminanceControl::Get().IsHdrOn(curScreenNode_->GetScreenId())) && + RSLuminanceControl::Get().IsHardwareHdrDisable(); + return (hasUniRenderHdrSurface && !RSHdrUtil::GetRGBA1010108Enabled()) || !drmNodes_.empty() || + hasFingerprint_ || isHdrHardwareDisabled; +} + void RSUniRenderVisitor::UpdatePointWindowDirtyStatus(std::shared_ptr& pointWindow) { if (!pointWindow->IsHardwareEnabledTopSurface()) { diff --git a/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.h b/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.h index ce6e53b5147167c613343b4484525feb64f5df9f..1ca8d418fe8a3c055313b0c84974a2baff1ab881 100644 --- a/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.h +++ b/rosen/modules/render_service/core/pipeline/main_thread/rs_uni_render_visitor.h @@ -320,6 +320,9 @@ private: void TryNotifyUIBufferAvailable(); + bool IsHwcNodeHardwareForcedDisabled(bool hasUniRenderHdrSurface, + const std::shared_ptr& hwcNodePtr) const; + void CollectSelfDrawingNodeRectInfo(RSSurfaceRenderNode& node); // Used to collect prepared subtree into the control-level occlusion culling handler. diff --git a/rosen/modules/render_service_base/include/display_engine/rs_luminance_control.h b/rosen/modules/render_service_base/include/display_engine/rs_luminance_control.h index 1ce0e5e15818c368c46e9d64b69dac5cced44620..9a75bae39702016954c6447628fbb05cb4a17eec 100644 --- a/rosen/modules/render_service_base/include/display_engine/rs_luminance_control.h +++ b/rosen/modules/render_service_base/include/display_engine/rs_luminance_control.h @@ -70,7 +70,7 @@ public: virtual bool IsHdrPictureOn() = 0; virtual bool IsForceCloseHdr() const = 0; virtual void ForceCloseHdr(uint32_t closeHdrSceneId, bool forceCloseHdr) = 0; - virtual bool IsCloseHardwareHdr() const = 0; + virtual bool IsHardwareHdrDisable() = 0; virtual bool IsScreenNoHeadroom(ScreenId) const = 0; virtual bool IsEnableImageDetailEnhance() = 0; }; @@ -103,7 +103,7 @@ public: RSB_EXPORT bool IsHdrPictureOn(); RSB_EXPORT bool IsForceCloseHdr(); RSB_EXPORT void ForceCloseHdr(uint32_t closeHdrSceneId, bool forceCloseHdr); - RSB_EXPORT bool IsCloseHardwareHdr(); + RSB_EXPORT bool IsHardwareHdrDisable() const; RSB_EXPORT bool IsScreenNoHeadroom(ScreenId screenId) const; RSB_EXPORT bool IsEnableImageDetailEnhance(); diff --git a/rosen/modules/render_service_base/src/display_engine/rs_luminance_control.cpp b/rosen/modules/render_service_base/src/display_engine/rs_luminance_control.cpp index 04dc1fdfc4af13756cf850c3cc7aeffaecc5800e..208764c4d6689b7d154cb243e03ed5672a346e7b 100644 --- a/rosen/modules/render_service_base/src/display_engine/rs_luminance_control.cpp +++ b/rosen/modules/render_service_base/src/display_engine/rs_luminance_control.cpp @@ -187,10 +187,10 @@ void RSLuminanceControl::ForceCloseHdr(uint32_t closeHdrSceneId, bool forceClose } } -bool RSLuminanceControl::IsCloseHardwareHdr() +bool RSLuminanceControl::IsHardwareHdrDisable() const { return (rSLuminanceControlInterface_ != nullptr) ? - rSLuminanceControlInterface_->IsCloseHardwareHdr() : false; + rSLuminanceControlInterface_->IsHardwareHdrDisable() : false; } bool RSLuminanceControl::IsScreenNoHeadroom(ScreenId screenId) const diff --git a/rosen/test/render_service/render_service/unittest/pipeline/BUILD.gn b/rosen/test/render_service/render_service/unittest/pipeline/BUILD.gn index 71773fb7439cfd2c01cb637ae308b96b7f459460..ee2d4c8763f3111a45fe9be5bcf171ca37a9b811 100644 --- a/rosen/test/render_service/render_service/unittest/pipeline/BUILD.gn +++ b/rosen/test/render_service/render_service/unittest/pipeline/BUILD.gn @@ -724,6 +724,7 @@ ohos_unittest("RSUniRenderVisitorTest") { "$graphic_2d_root/rosen/modules/render_service_base/src/pipeline/rs_canvas_render_node.cpp", "main_thread/rs_uni_render_visitor_test.cpp", "mock/mock_matrix.cpp", + "mock/mock_rs_luminance_control.cpp", ] deps = [ ":rs_test_common", @@ -857,7 +858,10 @@ ohos_unittest("RSHardwareThreadTest") { ## Build RSMainThreadTest ohos_unittest("RSMainThreadTest") { module_out_path = module_output_path - sources = [ "main_thread/rs_main_thread_test.cpp" ] + sources = [ + "main_thread/rs_main_thread_test.cpp", + "mock/mock_rs_luminance_control.cpp", + ] deps = [ ":rs_test_common", "$graphic_2d_root/rosen/modules/render_service_base/src/platform:platform", diff --git a/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_main_thread_test.cpp b/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_main_thread_test.cpp index 032473263d131ec815a48aa509fa79aafe59dc77..00b6430c07298b35fd813c753f7b8c4afec1ddfe 100644 --- a/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_main_thread_test.cpp +++ b/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_main_thread_test.cpp @@ -42,6 +42,7 @@ #include "drawable/rs_screen_render_node_drawable.h" #include "screen_manager/rs_screen.h" #include "pipeline/rs_render_node_gc.h" +#include "pipeline/mock/mock_rs_luminance_control.h" #if defined(ACCESSIBILITY_ENABLE) #include "accessibility_config.h" #endif @@ -6692,4 +6693,47 @@ HWTEST_F(RSMainThreadTest, MarkNodeImageDirty001, TestSize.Level1) uint64_t nodeId = 12345; mainThread->MarkNodeImageDirty(nodeId); } + +/** + * @tc.name: DisableHdrDirectCompositionTest001 + * @tc.desc: Test CollectInfoForHardwareComposer when hardware hdr is disabled. + * @tc.type: FUNC + * @tc.require:IBZ6NM + */ +HWTEST_F(RSMainThreadTest, DisableHdrDirectCompositionTest001, TestSize.Level1) +{ + auto mainThread = RSMainThread::Instance(); + ASSERT_NE(mainThread, nullptr); + bool isUniRender = mainThread->isUniRender_; + bool doDirectComposition = mainThread->doDirectComposition_; + mainThread->isUniRender_ = true; + mainThread->context_->GetMutableNodeMap().renderNodeMap_.clear(); + mainThread->context_->GetMutableNodeMap().surfaceNodeMap_.clear(); + RSSurfaceRenderNodeConfig config; + config.id = 1; + auto node1 = std::make_shared(config); + node1->SetIsOnTheTree(true); + mainThread->context_->GetMutableNodeMap().RegisterRenderNode(node1); + auto& originalInterface = RSLuminanceControl::Get().rSLuminanceControlInterface_; + Mock::RSLuminanceControlInterfaceMock mockInterface; + RSLuminanceControl::Get().rSLuminanceControlInterface_ = &mockInterface; + + mockInterface.isHardwareHdrDisabled_ = true; + node1->SetVideoHdrStatus(HdrStatus::HDR_VIDEO); + mainThread->CollectInfoForHardwareComposer(); + ASSERT_FALSE(mainThread->doDirectComposition_); + node1->GetMultableSpecialLayerMgr().Set(SpecialLayerType::PROTECTED, true); + mainThread->CollectInfoForHardwareComposer(); + ASSERT_FALSE(mainThread->doDirectComposition_); + node1->SetVideoHdrStatus(HdrStatus::NO_HDR); + mainThread->CollectInfoForHardwareComposer(); + ASSERT_FALSE(mainThread->doDirectComposition_); + mockInterface.isHardwareHdrDisabled_ = false; + mainThread->CollectInfoForHardwareComposer(); + ASSERT_FALSE(mainThread->doDirectComposition_); + + mainThread->isUniRender_ = isUniRender; + mainThread->doDirectComposition_ = doDirectComposition; + RSLuminanceControl::Get().rSLuminanceControlInterface_ = originalInterface; +} } // namespace OHOS::Rosen diff --git a/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_uni_render_visitor_test.cpp b/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_uni_render_visitor_test.cpp index 5e87cdc732fcb4d07b90fdf7f119441e51e4dbb3..e8c4b8fe3bc7805448bd03036fd8ca1c9e5b02d3 100755 --- a/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_uni_render_visitor_test.cpp +++ b/rosen/test/render_service/render_service/unittest/pipeline/main_thread/rs_uni_render_visitor_test.cpp @@ -45,6 +45,7 @@ #include "pipeline/rs_uni_render_judgement.h" #include "pipeline/main_thread/rs_uni_render_visitor.h" #include "pipeline/hwc/rs_uni_hwc_visitor.h" +#include "pipeline/mock/mock_rs_luminance_control.h" #include "screen_manager/rs_screen.h" #include "feature/occlusion_culling/rs_occlusion_handler.h" #include "feature/opinc/rs_opinc_manager.h" @@ -5671,4 +5672,182 @@ HWTEST_F(RSUniRenderVisitorTest, CollectSurfaceLockLayer001, TestSize.Level2) rsUniRenderVisitor->CollectSurfaceLockLayer(node); EXPECT_TRUE(RSMainThread::Instance()->HasDRMOrSurfaceLockLayer()); } + +/* + * @tc.name: DisableHardwareHdrTest001 + * @tc.desc: Test IsHdrUseUnirender with disable hardware hdr. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(RSUniRenderVisitorTest, DisableHardwareHdrTest001, TestSize.Level1) +{ + NodeId childId = 1; + auto childNode1 = std::make_shared(childId); + childNode1->SetIsOnTheTree(true); + childNode1->InitRenderParams(); + NodeId displayId = 1; + auto rsContext = std::make_shared(); + ASSERT_NE(rsContext, nullptr); + auto displayNode = std::make_shared(displayId, 0, rsContext); + auto rsUniRenderVisitor = std::make_shared(); + ASSERT_NE(rsUniRenderVisitor, nullptr); + rsUniRenderVisitor->curScreenNode_ = displayNode; + + childNode1->GetMultableSpecialLayerMgr().Set(SpecialLayerType::PROTECTED, true); + ASSERT_FALSE(rsUniRenderVisitor->IsHwcNodeHardwareForcedDisabled(true, childNode1)); + childNode1->GetMultableSpecialLayerMgr().Set(SpecialLayerType::PROTECTED, false); + ASSERT_TRUE(rsUniRenderVisitor->IsHwcNodeHardwareForcedDisabled(true, childNode1)); + childNode1 = nullptr; + ASSERT_FALSE(rsUniRenderVisitor->IsHwcNodeHardwareForcedDisabled(true, childNode1)); +} + +/* + * @tc.name: DisableHardwareHdrTest002 + * @tc.desc: Test HandlePixelFormat with disable hardware hdr. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(RSUniRenderVisitorTest, DisableHardwareHdrTest002, TestSize.Level1) +{ + auto& originalInterface = RSLuminanceControl::Get().rSLuminanceControlInterface_; + Mock::RSLuminanceControlInterfaceMock mockInterface; + RSLuminanceControl::Get().rSLuminanceControlInterface_ = &mockInterface; + auto rsContext = std::make_shared(); + ASSERT_NE(rsContext, nullptr); + auto rsScreenRenderNode = std::make_shared(11, 0, rsContext->weak_from_this()); + ASSERT_NE(rsScreenRenderNode, nullptr); + rsScreenRenderNode->dirtyManager_ = std::make_shared(); + ASSERT_NE(rsScreenRenderNode->dirtyManager_, nullptr); + auto screenManager = CreateOrGetScreenManager(); + auto screenId = CreateVirtualScreen(screenManager); + ASSERT_NE(screenId, INVALID_SCREEN_ID); + rsScreenRenderNode->stagingRenderParams_ = std::make_unique(screenId); + rsScreenRenderNode->CollectHdrStatus(HdrStatus::HDR_PHOTO); + mockInterface.isHardwareHdrDisabled_ = true; + rsScreenRenderNode->GetMutableRenderProperties().SetHDRBrightnessFactor(0.0f); + auto rsUniRenderVisitor = std::make_shared(); + ASSERT_NE(rsUniRenderVisitor, nullptr); + rsUniRenderVisitor->curScreenNode_ = rsScreenRenderNode; + + std::shared_ptr drmNode = RSTestUtil::CreateSurfaceNode(); + ASSERT_NE(drmNode, nullptr); + drmNode->GetRenderProperties().GetBoundsGeometry()->absRect_ = RectT(0, 0, 1, 1); + rsUniRenderVisitor->drmNodes_.emplace_back(drmNode); + rsUniRenderVisitor->QuickPrepareScreenRenderNode(*rsScreenRenderNode); + ASSERT_EQ(mockInterface.hdrStatus_, HdrStatus::NO_HDR); + rsScreenRenderNode->CollectHdrStatus(HdrStatus::HDR_PHOTO); + rsScreenRenderNode->GetMutableRenderProperties().SetHDRBrightnessFactor(0.5f); + rsUniRenderVisitor->QuickPrepareScreenRenderNode(*rsScreenRenderNode); + ASSERT_EQ(mockInterface.hdrStatus_, HdrStatus::NO_HDR); + if (!rsUniRenderVisitor->drmNodes_.empty()) { + rsUniRenderVisitor->drmNodes_.pop_back(); + } + rsScreenRenderNode->CollectHdrStatus(HdrStatus::HDR_PHOTO); + rsUniRenderVisitor->HandlePixelFormat(*rsScreenRenderNode); + ASSERT_EQ(mockInterface.hdrStatus_, HdrStatus::HDR_PHOTO); + mockInterface.isHardwareHdrDisabled_ = false; + rsScreenRenderNode->CollectHdrStatus(HdrStatus::HDR_PHOTO); + rsUniRenderVisitor->HandlePixelFormat(*rsScreenRenderNode); + ASSERT_EQ(mockInterface.hdrStatus_, HdrStatus::HDR_PHOTO); + RSLuminanceControl::Get().rSLuminanceControlInterface_ = originalInterface; +} + +/* + * @tc.name: DisableHardwareHdrTest003 + * @tc.desc: Test HandlePixelFormat with disable hardware hdr. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(RSUniRenderVisitorTest, DisableHardwareHdrTest003, TestSize.Level1) +{ + auto& originalInterface = RSLuminanceControl::Get().rSLuminanceControlInterface_; + Mock::RSLuminanceControlInterfaceMock mockInterface; + RSLuminanceControl::Get().rSLuminanceControlInterface_ = &mockInterface; + auto rsContext = std::make_shared(); + ASSERT_NE(rsContext, nullptr); + auto rsScreenRenderNode = std::make_shared(11, 0, rsContext->weak_from_this()); + ASSERT_NE(rsScreenRenderNode, nullptr); + rsScreenRenderNode->dirtyManager_ = std::make_shared(); + ASSERT_NE(rsScreenRenderNode->dirtyManager_, nullptr); + auto screenManager = CreateOrGetScreenManager(); + auto screenId = CreateVirtualScreen(screenManager); + ASSERT_NE(screenId, INVALID_SCREEN_ID); + rsScreenRenderNode->stagingRenderParams_ = std::make_unique(screenId); + auto param = static_cast(rsScreenRenderNode->stagingRenderParams_.get()); + rsScreenRenderNode->GetMutableRenderProperties().SetHDRBrightnessFactor(0.0f); + rsScreenRenderNode->SetHasUniRenderHdrSurface(false); + auto rsUniRenderVisitor = std::make_shared(); + ASSERT_NE(rsUniRenderVisitor, nullptr); + rsUniRenderVisitor->curScreenNode_ = rsScreenRenderNode; + + mockInterface.isHdrOn_ = true; + mockInterface.isHardwareHdrDisabled_ = false; + rsScreenRenderNode->SetHDRPresent(true); + rsUniRenderVisitor->QuickPrepareScreenRenderNode(*rsScreenRenderNode); + ASSERT_FALSE(param->GetHDRPresent()); + mockInterface.isHardwareHdrDisabled_ = true; + rsScreenRenderNode->SetHDRPresent(true); + rsScreenRenderNode->SetHasUniRenderHdrSurface(false); + rsUniRenderVisitor->QuickPrepareScreenRenderNode(*rsScreenRenderNode); + ASSERT_TRUE(param->GetHDRPresent()); + rsScreenRenderNode->SetHDRPresent(true); + rsScreenRenderNode->SetHasUniRenderHdrSurface(true); + // avoid reset SetHasUniRenderHdrSurface + rsUniRenderVisitor->HandlePixelFormat(*rsScreenRenderNode); + ASSERT_TRUE(param->GetHDRPresent()); + mockInterface.isHardwareHdrDisabled_ = false; + rsScreenRenderNode->SetHDRPresent(true); + rsScreenRenderNode->SetHasUniRenderHdrSurface(true); + rsUniRenderVisitor->HandlePixelFormat(*rsScreenRenderNode); + ASSERT_TRUE(param->GetHDRPresent()); + + RSLuminanceControl::Get().rSLuminanceControlInterface_ = originalInterface; +} + +/* + * @tc.name: DisableHardwareHdrTest004 + * @tc.desc: Test IsHdrUseUnirender with disable hardware hdr. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(RSUniRenderVisitorTest, DisableHardwareHdrTest004, TestSize.Level1) +{ + auto& originalInterface = RSLuminanceControl::Get().rSLuminanceControlInterface_; + Mock::RSLuminanceControlInterfaceMock mockInterface; + RSLuminanceControl::Get().rSLuminanceControlInterface_ = &mockInterface; + auto node = RSTestUtil::CreateSurfaceNodeWithBuffer(); + NodeId childId = 1; + auto childNode1 = std::make_shared(childId); + childNode1->SetIsOnTheTree(true); + childNode1->InitRenderParams(); + node->AddChildHardwareEnabledNode(childNode1); + NodeId displayId = 1; + auto rsContext = std::make_shared(); + ASSERT_NE(rsContext, nullptr); + auto displayNode = std::make_shared(displayId, 0, rsContext); + auto rsUniRenderVisitor = std::make_shared(); + ASSERT_NE(rsUniRenderVisitor, nullptr); + rsUniRenderVisitor->curScreenNode_ = displayNode; + + childNode1->hasFingerprint_ = false; + mockInterface.isHardwareHdrDisabled_ = false; + mockInterface.isHdrOn_ = true; + rsUniRenderVisitor->UpdateHwcNodeDirtyRegionAndCreateLayer(node); + ASSERT_FALSE(childNode1->isHardwareForcedDisabled_); + mockInterface.isHardwareHdrDisabled_ = true; + rsUniRenderVisitor->UpdateHwcNodeDirtyRegionAndCreateLayer(node); + ASSERT_TRUE(childNode1->isHardwareForcedDisabled_); + childNode1->hasFingerprint_ = true; + rsUniRenderVisitor->UpdateHwcNodeDirtyRegionAndCreateLayer(node); + ASSERT_TRUE(childNode1->isHardwareForcedDisabled_); + std::shared_ptr drmNode = RSTestUtil::CreateSurfaceNode(); + ASSERT_NE(drmNode, nullptr); + drmNode->GetRenderProperties().GetBoundsGeometry()->absRect_ = RectT(0, 0, 1, 1); + rsUniRenderVisitor->drmNodes_.emplace_back(drmNode); + rsUniRenderVisitor->UpdateHwcNodeDirtyRegionAndCreateLayer(node); + ASSERT_TRUE(childNode1->isHardwareForcedDisabled_); + displayNode->SetHasUniRenderHdrSurface(true); + ASSERT_TRUE(childNode1->isHardwareForcedDisabled_); + RSLuminanceControl::Get().rSLuminanceControlInterface_ = originalInterface; +} } // OHOS::Rosen \ No newline at end of file diff --git a/rosen/test/render_service/render_service/unittest/pipeline/mock/mock_rs_luminance_control.cpp b/rosen/test/render_service/render_service/unittest/pipeline/mock/mock_rs_luminance_control.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8882999608115b1dfa83dd2670096850fe4e0257 --- /dev/null +++ b/rosen/test/render_service/render_service/unittest/pipeline/mock/mock_rs_luminance_control.cpp @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "mock_rs_luminance_control.h" + +namespace OHOS { +namespace Rosen { +namespace Mock { +namespace { +constexpr uint32_t HDR_LUMINANCE = 65535; +constexpr float SDR_DISPLAY_NITS = 500.0f; +constexpr float DISPLAY_NITS = 1000.0f; +constexpr float NON_LINEAR_RATIO = 0.7f; +constexpr float HDR_SCALAR = 5.0f; +} + +bool RSLuminanceControlInterfaceMock::Init() +{ + return true; +} + +bool RSLuminanceControlInterfaceMock::SetHdrStatus([[maybe_unused]] ScreenId screenId, HdrStatus hdrStatus) +{ + hdrStatus_ = hdrStatus; + return true; +} + +bool RSLuminanceControlInterfaceMock::IsHdrOn([[maybe_unused]] ScreenId screenId) const +{ + return isHdrOn_; +} + +bool RSLuminanceControlInterfaceMock::IsDimmingOn([[maybe_unused]] ScreenId screenId) +{ + return true; +} + +void RSLuminanceControlInterfaceMock::DimmingIncrease([[maybe_unused]] ScreenId screenId) {} + +void RSLuminanceControlInterfaceMock::SetSdrLuminance([[maybe_unused]] ScreenId screenId, + [[maybe_unused]] uint32_t level) {} + +uint32_t RSLuminanceControlInterfaceMock::GetNewHdrLuminance([[maybe_unused]] ScreenId screenId) +{ + return HDR_LUMINANCE; +} + +void RSLuminanceControlInterfaceMock::SetNowHdrLuminance([[maybe_unused]] ScreenId screenId, + [[maybe_unused]] uint32_t level) {} + +bool RSLuminanceControlInterfaceMock::IsNeedUpdateLuminance([[maybe_unused]] ScreenId screenId) +{ + return true; +} + +float RSLuminanceControlInterfaceMock::GetSdrDisplayNits([[maybe_unused]] ScreenId screenId) +{ + return SDR_DISPLAY_NITS; +} + +float RSLuminanceControlInterfaceMock::GetDisplayNits([[maybe_unused]] ScreenId screenId) +{ + return DISPLAY_NITS; +} + +double RSLuminanceControlInterfaceMock::GetNonlinearRatio([[maybe_unused]] ScreenId screenId, uint32_t mode) +{ + return NON_LINEAR_RATIO; +} + +float RSLuminanceControlInterfaceMock::CalScaler([[maybe_unused]] const float& maxContentLightLevel, + [[maybe_unused]] const std::vector& dynamicMetadata, [[maybe_unused]] const float& ratio) +{ + return HDR_SCALAR; +} + +bool RSLuminanceControlInterfaceMock::IsHdrPictureOn() +{ + return true; +} + +bool RSLuminanceControlInterfaceMock::IsForceCloseHdr() const +{ + return false; +} + +void RSLuminanceControlInterfaceMock::ForceCloseHdr([[maybe_unused]] uint32_t closeHdrSceneId, + [[maybe_unused]] bool forceCloseHdr) {} + +bool RSLuminanceControlInterfaceMock::IsHardwareHdrDisable([[maybe_unused]] bool checkBrightnessRatio, + [[maybe_unused]] ScreenId screenId) +{ + return isHardwareHdrDisabled_; +} + +bool RSLuminanceControlInterfaceMock::IsScreenNoHeadroom([[maybe_unused]] ScreenId screenId) const +{ + return true; +} + +bool RSLuminanceControlInterfaceMock::IsEnableImageDetailEnhance() +{ + return false; +} +} // Mock +} // Rosen +} // OHOS \ No newline at end of file diff --git a/rosen/test/render_service/render_service/unittest/pipeline/mock/mock_rs_luminance_control.h b/rosen/test/render_service/render_service/unittest/pipeline/mock/mock_rs_luminance_control.h new file mode 100644 index 0000000000000000000000000000000000000000..400c835358ad381cd82e04bb173fef19acae0f60 --- /dev/null +++ b/rosen/test/render_service/render_service/unittest/pipeline/mock/mock_rs_luminance_control.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef GRAPHIC_RS_LUMINANCE_CONTROL_MOCK_H +#define GRAPHIC_RS_LUMINANCE_CONTROL_MOCK_H + +#include "display_engine/rs_luminance_control.h" + +#include + +namespace OHOS { +namespace Rosen { +namespace Mock { +class RSLuminanceControlInterfaceMock : public RSLuminanceControlInterface { +public: + RSLuminanceControlInterfaceMock() = default; + ~RSLuminanceControlInterfaceMock() override = default; + + bool Init() override; + bool SetHdrStatus(ScreenId screenId, HdrStatus hdrStatus) override; + bool IsHdrOn(ScreenId screenId) const override; + bool IsDimmingOn(ScreenId screenId) override; + void DimmingIncrease(ScreenId screenId) override; + void SetSdrLuminance(ScreenId screenId, uint32_t level) override; + uint32_t GetNewHdrLuminance(ScreenId screenId) override; + void SetNowHdrLuminance(ScreenId screenId, uint32_t level) override; + bool IsNeedUpdateLuminance(ScreenId screenId) override; + float GetSdrDisplayNits(ScreenId screenId) override; + float GetDisplayNits(ScreenId screenId) override; + double GetNonlinearRatio(ScreenId screenId, uint32_t mode) override; + float CalScaler(const float& maxContentLightLevel, + const std::vector& dynamicMetadata, const float& ratio) override; + bool IsHdrPictureOn() override; + bool IsForceCloseHdr() const override; + void ForceCloseHdr(uint32_t closeHdrSceneId, bool forceCloseHdr) override; + bool IsHardwareHdrDisable(bool checkBrightnessRatio, ScreenId screenId) override; + bool IsScreenNoHeadroom(ScreenId screenId) const override; + bool IsEnableImageDetailEnhance() override; + + bool isHardwareHdrDisabled_{false}; + bool isHdrOn_{false}; + HdrStatus hdrStatus_{HdrStatus::NO_HDR}; +}; +} //Mock +} //Rosen +} // OHOS + +#endif // GRAPHIC_RS_LUMINANCE_CONTROL_MOCK_H