diff --git a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.cpp b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.cpp index 6679608702827b18313be712cad7dd17349a0cef..4c9da8ed7876e4927974daa0010b58f5927dd17f 100644 --- a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.cpp +++ b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.cpp @@ -661,8 +661,9 @@ void RSHardwareThread::PreAllocateProtectedBuffer(sptr buffer, ui frameBufferSurfaceOhosMap_[surfaceId] = rsSurface; } } + // SetColorSpace - rsSurface->SetColorSpace(ComputeTargetColorGamut(buffer)); + rsSurface->SetColorSpace(ComputeTargetColorGamut(buffer, IsScreenSupportBt2020(screenId))); // SetSurfacePixelFormat rsSurface->SetSurfacePixelFormat(ComputeTargetPixelFormat(buffer)); @@ -676,7 +677,8 @@ void RSHardwareThread::PreAllocateProtectedBuffer(sptr buffer, ui #endif } -GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const sptr &buffer) +GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const sptr &buffer, + bool isPanelSupportBt2020) { GraphicColorGamut colorGamut = GRAPHIC_COLOR_GAMUT_SRGB; #ifdef USE_VIDEO_PROCESSING_ENGINE @@ -685,11 +687,19 @@ GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const sptr& surface, const std::vectorQueryScreenInfo(screenId); std::shared_ptr drawingColorSpace = nullptr; #ifdef USE_VIDEO_PROCESSING_ENGINE - GraphicColorGamut colorGamut = ComputeTargetColorGamut(layers); + + GraphicColorGamut colorGamut = ComputeTargetColorGamut(layers, IsScreenSupportBt2020(screenId)); GraphicPixelFormat pixelFormat = ComputeTargetPixelFormat(layers); RS_LOGD("Redraw computed target color gamut: %{public}d," "pixel format: %{public}d, frame width: %{public}d, frame height: %{public}d", @@ -1042,8 +1053,28 @@ void RSHardwareThread::DumpEventQueue() } } +bool RSHardwareThread::IsScreenSupportBt2020(uint64_t screenId) const +{ + auto screenManager = CreateOrGetScreenManager(); + if (screenManager == nullptr) { + RS_LOGE("IsScreenSupportBt2020 screenManager is null"); + return false; + } + std::vector modes{}; + int32_t ret = screenManager->GetScreenSupportedColorGamuts(screenId, modes); + for (auto gamut : modes) { + RS_LOGE("IsScreenSupportBt2020 Screen Id=%{public}d", static_cast(screenId)); + RS_LOGE("IsScreenSupportBt2020 ScreenSupportedColorGamut=%{public}d", gamut); + if (gamut == COLOR_GAMUT_BT2020 || gamut == COLOR_GAMUT_DISPLAY_BT2020) { + return true; + } + } + return false; +} + #ifdef USE_VIDEO_PROCESSING_ENGINE -GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const std::vector& layers) +GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const std::vector& layers, + bool isPanelSupportBt2020) { using namespace HDI::Display::Graphic::Common::V1_0; GraphicColorGamut colorGamut = GRAPHIC_COLOR_GAMUT_SRGB; @@ -1067,11 +1098,16 @@ GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const std::vector buffer, uint64_t screenId); void ChangeLayersForActiveRectOutside(std::vector& layers, ScreenId screenId); void DumpVkImageInfo(std::string &dumpString); + bool IsScreenSupportBt2020(uint64_t screenId) const; int64_t GetDelayTime() { @@ -98,14 +99,16 @@ private: sptr saStatusChangeListener_ = nullptr; #endif #ifdef USE_VIDEO_PROCESSING_ENGINE - static GraphicColorGamut ComputeTargetColorGamut(const std::vector& layers); + static GraphicColorGamut ComputeTargetColorGamut(const std::vector& layers, + bool isPanelSupportBt2020); static GraphicPixelFormat ComputeTargetPixelFormat(const std::vector& layers); static bool IsAllRedraw(const std::vector& layers); static bool ConvertColorGamutToSpaceType(const GraphicColorGamut& colorGamut, HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType& colorSpaceInfo); #endif - static GraphicColorGamut ComputeTargetColorGamut(const sptr &buffer); + static GraphicColorGamut ComputeTargetColorGamut(const sptr &buffer, + bool isPanelSupportBt2020); static GraphicPixelFormat ComputeTargetPixelFormat(const sptr &buffer); std::shared_ptr runner_ = nullptr; std::shared_ptr handler_ = nullptr; diff --git a/rosen/modules/render_service_base/BUILD.gn b/rosen/modules/render_service_base/BUILD.gn index 1d1c429c8fb40b9ca03f9c0c5d40a5fdcbfd2a71..d1f5b61f3ae78391e0e75f682661125f606621d4 100644 --- a/rosen/modules/render_service_base/BUILD.gn +++ b/rosen/modules/render_service_base/BUILD.gn @@ -382,6 +382,7 @@ ohos_source_set("render_service_base_src") { "src/feature/opinc/rs_opinc_manager.cpp", "src/feature/single_frame_composer/rs_single_frame_composer.cpp", "src/feature/capture/rs_capture_pixelmap_manager.cpp", + "src/feature/hdr/rs_gamut_collector.cpp", #dirty_region "src/dirty_region/rs_filter_dirty_collector.cpp", diff --git a/rosen/modules/render_service_base/include/feature/hdr/rs_gamut_collector.h b/rosen/modules/render_service_base/include/feature/hdr/rs_gamut_collector.h new file mode 100644 index 0000000000000000000000000000000000000000..019505b7fa005bb20a02605bc23898f60f248da6 --- /dev/null +++ b/rosen/modules/render_service_base/include/feature/hdr/rs_gamut_collector.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2021-2023 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 RENDER_SERVICE_GAMUT_COLLECTOR_H +#define RENDER_SERVICE_GAMUT_COLLECTOR_H + +#include +#include +#include +#include +#include +#include +#include "surface_type.h" + +namespace OHOS { +namespace Rosen { +class OcclusionNode; +class RSCommand; +class RSDirtyReginManager; +class RSOcclusionHandler; +class RSSurfaceHandler; +class GamutCollector { +public: + GamutCollector() = default; + ~GamutCollector() = default; + static void IncreaseInner(GraphicColorGamut gamut, int& bt200, int& p3); + static void DecreaseInner(GraphicColorGamut gamut, int& bt200, int& p3); + void IncreaseGamutCount(GraphicColorGamut gamut); + void DecreaseGamutCount(GraphicColorGamut gamut); + void IncreaseSurfaceGamutCount(GraphicColorGamut gamut); + void DecreaseSurfaceGamutCount(GraphicColorGamut gamut); + void IncreaseResourceGamutCount(GraphicColorGamut gamut); + void DecreaseResourceGamutCount(GraphicColorGamut gamut); + GraphicColorGamut GetCurGamut() const; + GraphicColorGamut GetFirstLevelNodeGamut() const; + static GraphicColorGamut MapGamutToStandard(GraphicColorGamut gamut); + static GraphicColorGamut DetermineGamutStandard(int bt2020Num, int p3Num); + uint32_t GetBt2020Num() const; + uint32_t GetP3Num() const; + +private: + int bt2020Num_ = 0; + int p3Num_ = 0; + int firstLevelNodeBt2020SurfaceNum_ = 0; + int firstLevelNodeP3SurfaceNum_ = 0; + int firstLevelNodeBt2020ResourceNum_ = 0; + int firstLevelNodeP3ResourceNum_ = 0; +}; +} // namespace Rosen +} // namespace OHOS + +#endif // RENDER_SERVICE_GAMUT_COLLECTOR_H \ No newline at end of file diff --git a/rosen/modules/render_service_base/include/pipeline/rs_surface_render_node.h b/rosen/modules/render_service_base/include/pipeline/rs_surface_render_node.h index 105616f359b4b22112fc9339a5894ed1c803c31b..6e1af88e4536ebaa31b8ba2249f96db03d055ac3 100644 --- a/rosen/modules/render_service_base/include/pipeline/rs_surface_render_node.h +++ b/rosen/modules/render_service_base/include/pipeline/rs_surface_render_node.h @@ -36,6 +36,7 @@ #include "pipeline/rs_render_node.h" #include "pipeline/rs_surface_handler.h" #include "pipeline/rs_uni_render_judgement.h" +#include "feature/hdr/rs_gamut_collector.h" #include "platform/common/rs_surface_ext.h" #include "platform/common/rs_system_properties.h" #include "property/rs_properties_painter.h" @@ -1929,28 +1930,7 @@ private: size_t dirtyContentNodeNum_ = 0; size_t dirtyGeoNodeNum_ = 0; size_t dirtynodeNum_ = 0; - struct GamutCollector - { - int bt2020Num_ = 0; - int p3Num_ = 0; - int firstLevelNodeBt2020SurfaceNum_ = 0; - int firstLevelNodeP3SurfaceNum_ = 0; - int firstLevelNodeBt2020ResourceNum_ = 0; - int firstLevelNodeP3ResourceNum_ = 0; - - static void IncreaseInner(GraphicColorGamut gamut, int& bt2020, int& p3); - static void DecreaseInner(GraphicColorGamut gamut, int& bt2020, int& p3); - void IncreaseGamutCount(GraphicColorGamut gamut); - void DecreaseGamutCount(GraphicColorGamut gamut); - void IncreaseSurfaceGamutCount(GraphicColorGamut gamut); - void DecreaseSurfaceGamutCount(GraphicColorGamut gamut); - void IncreaseResourceGamutCount(GraphicColorGamut gamut); - void DecreaseResourceGamutCount(GraphicColorGamut gamut); - GraphicColorGamut GetCurGamut() const; - GraphicColorGamut GetFirstLevelNodeGamut() const; - static GraphicColorGamut MapGamutToStandard(GraphicColorGamut gamut); - static GraphicColorGamut DetermineGamutStandard(int pt2020Num, int p3Num); - }; + GamutCollector gamutCollector_; // UIFirst int64_t uifirstStartTime_ = -1; diff --git a/rosen/modules/render_service_base/src/feature/hdr/rs_gamut_collector.cpp b/rosen/modules/render_service_base/src/feature/hdr/rs_gamut_collector.cpp new file mode 100644 index 0000000000000000000000000000000000000000..09d521d6660e86a6ac154840937ccf43d4ef8611 --- /dev/null +++ b/rosen/modules/render_service_base/src/feature/hdr/rs_gamut_collector.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2021-2023 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 "feature/hdr/rs_gamut_collector.h" +#include "platform/common/rs_system_properties.h" +#include "common/rs_common_hook.h" + +namespace OHOS { +namespace Rosen { +void GamutCollector::IncreaseInner(GraphicColorGamut gamut, int& bt200, int& p3) +{ + if (gamut == GRAPHIC_COLOR_GAMUT_DISPLAY_P3) { + ++p3; + } else if (gamut == GRAPHIC_COLOR_GAMUT_BT2020) { + ++bt2020; + } +} + +void GamutCollector::DecreaseInner(GraphicColorGamut gamut, int& bt200, int& p3) +{ + if (gamut == GRAPHIC_COLOR_GAMUT_DISPLAY_P3) { + --p3; + } else if (gamut == GRAPHIC_COLOR_GAMUT_BT2020) { + --bt2020; + } +} + +void GamutCollector::IncreaseGamutCount(GraphicColorGamut gamut) +{ + IncreaseInner(gamut, bt2020Num_, p3Num_); +} + +void GamutCollector::DecreaseGamutCount(GraphicColorGamut gamut) +{ + DecreaseInner(gamut, bt2020Num_, p3Num_); +} + +void GamutCollector::IncreaseSurfaceGamutCount(GraphicColorGamut gamut) +{ + IncreaseInner(gamut, firstLevelNodeBt2020SurfaceNum_, firstLevelNodeP3SurfaceNum_); +} + +void GamutCollector::DecreaseSurfaceGamutCount(GraphicColorGamut gamut) +{ + DecreaseInner(gamut, firstLevelNodeBt2020SurfaceNum_, firstLevelNodeP3SurfaceNum_); +} + +void GamutCollector::IncreaseResourceGamutCount(GraphicColorGamut gamut) +{ + IncreaseInner(gamut, firstLevelNodeBt2020ResourceNum_, firstLevelNodeP3ResourceNum_); +} + +void GamutCollector::DecreaseResourceGamutCount(GraphicColorGamut gamut) +{ + DecreaseInner(gamut, firstLevelNodeBt2020ResourceNum_, firstLevelNodeP3ResourceNum_); +} + +GraphicColorGamut GamutCollector::GetCurGamut() const +{ + return DetermineGamutStandard(bt2020Num_, p3Num_); +} + +GraphicColorGamut GamutCollector::GetFirstLevelNodeGamut() const +{ + if (!RSSystemProperties::GetWideColorSpaceEnabled()) { + return GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB + } + int bt2020Num = firstLevelNodeBt2020SurfaceNum_; + int p3Num = firstLevelNodeP3SurfaceNum_; + if (RsCommonHook::Instance().IsAdaptiveColorGamutEnabled()) { + bt2020Num += firstLevelNodeBt2020ResourceNum_; + p3Num += firstLevelNodeP3ResourceNum_; + } + GraphicColorGamut finalGamut = DetermineGamutStandard(bt2020Num, p3Num); + return finalGamut; +} + +GraphicColorGamut GamutCollector::MapGamutToStandard(GraphicColorGamut gamut) +{ + switch (gamut) { + case GRAPHIC_COLOR_GAMUT_ADOBE_RGB: + case GRAPHIC_COLOR_GAMUT_DCI_P3: + case GRAPHIC_COLOR_GAMUT_DISPLAY_P3: + return GRAPHIC_COLOR_GAMUT_DISPLAY_P3; + case GRAPHIC_COLOR_GAMUT_BT2020: + case GRAPHIC_COLOR_GAMUT_BT2100_PQ: + case GRAPHIC_COLOR_GAMUT_BT2100_HLG: + case GRAPHIC_COLOR_GAMUT_DISPLAY_BT2020: + return GRAPHIC_COLOR_GAMUT_BT2020; + default: + return GRAPHIC_COLOR_GAMUT_SRGB; + } +} + +GraphicColorGamut GamutCollector::DetermineGamutStandard(int bt2020Num, int p3Num) +{ + if (bt2020Num > 0) { + return GRAPHIC_COLOR_GAMUT_BT2020; + } else if (p3Num > 0) { + return GRAPHIC_COLOR_GAMUT_DISPLAY_P3; + } else { + return GRAPHIC_COLOR_GAMUT_SRGB; + } +} + +uint32_t GetBt2020Num() const +{ + return bt2020Num_; +} + +uint32_t GetP3Num() const +{ + return p3Num_; +} +} // namespace Rosen +} // namespace OHOS + + diff --git a/rosen/modules/render_service_base/src/pipeline/rs_surface_render_node.cpp b/rosen/modules/render_service_base/src/pipeline/rs_surface_render_node.cpp index 07519ed8047ce3ea77a32660a447eb0444ec0472..5e79e48f412d20b581a5d1351abe21f877816945 100644 --- a/rosen/modules/render_service_base/src/pipeline/rs_surface_render_node.cpp +++ b/rosen/modules/render_service_base/src/pipeline/rs_surface_render_node.cpp @@ -1396,8 +1396,8 @@ GraphicColorGamut RSSurfaceRenderNode::GetColorSpace() const int bt2020Num = 0; int p3Num = 0; if (RsCommonHook::Instance().IsAdaptiveColorGamutEnabled()) { - bt2020Num = gamutCollector_.bt2020Num_; - p3Num = gamutCollector_.p3Num_; + bt2020Num = gamutCollector_.GetBt2020Num(); + p3Num = gamutCollector_.GetP3Num(); } GraphicColorGamut selfGamut = GamutCollector::MapGamutToStandard(colorSpace_); GamutCollector::IncreaseInner(selfGamut, bt2020Num, p3Num); @@ -3706,101 +3706,5 @@ bool RSSurfaceRenderNode::isForcedClipHole() const } return (tvPlayerBundleName == bundleName_); } - -void RSSurfaceRenderNode::GamutCollector::IncreaseInner(GraphicColorGamut gamut, int& bt2020, int& p3) -{ - if (gamut == GRAPHIC_COLOR_GAMUT_DISPLAY_P3) { - ++p3; - } else if (gamut == GRAPHIC_COLOR_GAMUT_BT2020) { - ++bt2020; - } -} - -void RSSurfaceRenderNode::GamutCollector::DecreaseInner(GraphicColorGamut gamut, int& bt2020, int& p3) -{ - if (gamut == GRAPHIC_COLOR_GAMUT_DISPLAY_P3) { - --p3; - } else if (gamut == GRAPHIC_COLOR_GAMUT_BT2020) { - --bt2020; - } -} - -void RSSurfaceRenderNode::GamutCollector::IncreaseGamutCount(GraphicColorGamut gamut) -{ - IncreaseInner(gamut, bt2020Num_, p3Num_); -} - -void RSSurfaceRenderNode::GamutCollector::DecreaseGamutCount(GraphicColorGamut gamut) -{ - DecreaseInner(gamut, bt2020Num_, p3Num_); -} - -void RSSurfaceRenderNode::GamutCollector::IncreaseSurfaceGamutCount(GraphicColorGamut gamut) -{ - IncreaseInner(gamut, firstLevelNodeBt2020SurfaceNum_, firstLevelNodeP3SurfaceNum_); -} - -void RSSurfaceRenderNode::GamutCollector::DecreaseSurfaceGamutCount(GraphicColorGamut gamut) -{ - DecreaseInner(gamut, firstLevelNodeBt2020SurfaceNum_, firstLevelNodeP3SurfaceNum_); -} - -void RSSurfaceRenderNode::GamutCollector::IncreaseResourceGamutCount(GraphicColorGamut gamut) -{ - IncreaseInner(gamut, firstLevelNodeBt2020SurfaceNum_, firstLevelNodeP3SurfaceNum_); -} - -void RSSurfaceRenderNode::GamutCollector::DecreaseResourceGamutCount(GraphicColorGamut gamut) -{ - DecreaseInner(gamut, firstLevelNodeBt2020SurfaceNum_, firstLevelNodeP3SurfaceNum_); -} - -GraphicColorGamut RSSurfaceRenderNode::GamutCollector::GetCurGamut() const -{ - return DetermineGamutStandard(bt2020Num_, p3Num_); -} - -GraphicColorGamut RSSurfaceRenderNode::GamutCollector::GetFirstLevelNodeGamut() const -{ - if (!RSSystemProperties::GetWideColorSpaceEnabled()) { - return GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB; - } - int bt2020Num = firstLevelNodeBt2020SurfaceNum_; - int p3Num = firstLevelNodeP3SurfaceNum_; - if (RsCommonHook::Instance().IsAdaptiveColorGamutEnabled()) { - bt2020Num += firstLevelNodeBt2020ResourceNum_; - p3Num += firstLevelNodeP3ResourceNum_; - } - GraphicColorGamut finalGamut = DetermineGamutStandard(bt2020Num, p3Num); - return finalGamut; -} - -GraphicColorGamut RSSurfaceRenderNode::GamutCollector::MapGamutToStandard(GraphicColorGamut gamut) -{ - switch (gamut) { - case GRAPHIC_COLOR_GAMUT_ADOBE_RGB: - case GRAPHIC_COLOR_GAMUT_DCI_P3: - case GRAPHIC_COLOR_GAMUT_DISPLAY_P3: - return GRAPHIC_COLOR_GAMUT_DISPLAY_P3; - case GRAPHIC_COLOR_GAMUT_BT2020: - case GRAPHIC_COLOR_GAMUT_BT2100_PQ: - case GRAPHIC_COLOR_GAMUT_BT2100_HLG: - case GRAPHIC_COLOR_GAMUT_DISPLAY_BT2020: - return GRAPHIC_COLOR_GAMUT_BT2020; - default: - return GRAPHIC_COLOR_GAMUT_SRGB; - } -} - -GraphicColorGamut RSSurfaceRenderNode::GamutCollector::DetermineGamutStandard(int bt2020Num, int p3Num) -{ - if (bt2020Num > 0) { - return GRAPHIC_COLOR_GAMUT_BT2020; - } else if (p3Num > 0) { - return GRAPHIC_COLOR_GAMUT_DISPLAY_P3; - } else { - return GRAPHIC_COLOR_GAMUT_SRGB; - } -} } // namespace Rosen -} // namespace OHOS +} // namespace OHOS \ No newline at end of file diff --git a/rosen/test/render_service/render_service/unittest/pipeline/hardware_thread/rs_hardware_thread_test.cpp b/rosen/test/render_service/render_service/unittest/pipeline/hardware_thread/rs_hardware_thread_test.cpp index 0445779ccd50c4dee1d6cbc1c128e26cfdcf6fcd..5ec1168926b51a36ab6e3487e23dc9900b066fcd 100644 --- a/rosen/test/render_service/render_service/unittest/pipeline/hardware_thread/rs_hardware_thread_test.cpp +++ b/rosen/test/render_service/render_service/unittest/pipeline/hardware_thread/rs_hardware_thread_test.cpp @@ -869,13 +869,16 @@ HWTEST_F(RSHardwareThreadTest, ComputeTargetColorGamut001, TestSize.Level1) sptr requestFence = SyncFence::INVALID_FENCE; GSError ret = sProducer->RequestBuffer(buffer, requestFence, requestConfig); EXPECT_EQ(ret, GSERROR_OK); + GraphicColorGamut colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, false); GraphicColorGamut colorGamut = hardwareThread.ComputeTargetColorGamut(buffer); EXPECT_EQ(colorGamut, GRAPHIC_COLOR_GAMUT_DISPLAY_P3); requestConfig.colorGamut = GRAPHIC_COLOR_GAMUT_DISPLAY_P3; ret = sProducer->RequestBuffer(buffer, requestFence, requestConfig); EXPECT_EQ(ret, GSERROR_OK); - colorGamut = hardwareThread.ComputeTargetColorGamut(buffer); + colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, false); + EXPECT_EQ(colorGamut, GRAPHIC_COLOR_GAMUT_DISPLAY_P3); + colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, true); EXPECT_EQ(colorGamut, GRAPHIC_COLOR_GAMUT_DISPLAY_P3); } @@ -886,7 +889,10 @@ HWTEST_F(RSHardwareThreadTest, ComputeTargetColorGamut001, TestSize.Level1) * EnvConditions: N/A * CaseDescription: 1. preSetup: create bufferqueue(1 buffer) * 2. operation: RequestBuffer, SetColorSpaceInfo and ComputeTargetColorGamut - * 3. result: return colorGamut which is GRAPHIC_COLOR_GAMUT_SRGB + * 3. result: return colorGamut GRAPHIC_COLOR_GAMUT_DISPLAY_P3 if screen does not + * support BT2020 or screen supports BT2020 but requestConfig.colorGamut is set to + * GRAPHIC_COLOR_GAMUT_DISPLAY_P3, return colorGamut GRAPHIC_COLOR_GAMUT_BT2020 if screen + * supports BT2020 and requestConfig.colorGamut is set to GRAPHIC_COLOR_GAMUT_BT2020 */ HWTEST_F(RSHardwareThreadTest, ComputeTargetColorGamut002, TestSize.Level1) { @@ -906,8 +912,30 @@ HWTEST_F(RSHardwareThreadTest, ComputeTargetColorGamut002, TestSize.Level1) }; auto retSet = MetadataHelper::SetColorSpaceInfo(buffer, infoSet); EXPECT_EQ(retSet, GSERROR_OK); - GraphicColorGamut colorGamut = hardwareThread.ComputeTargetColorGamut(buffer); + GraphicColorGamut colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, false); EXPECT_EQ(colorGamut, GRAPHIC_COLOR_GAMUT_SRGB); + + infoSet.primaries = COLORPRIMARIES_P3_D65; + retSet = MetadataHelper::SetColorSpaceInfo(buffer, infoSet); + EXPECT_EQ(ret, GSERROR_OK); + colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, false); + EXPECT_EQ(colorGamut, GRAPHIC_COLOR_DISPLAY_P3); + + retSet = MetadataHelper::SetColorSpaceInfo(buffer, infoSet); + EXPECT_EQ(ret, GSERROR_OK); + colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, true); + EXPECT_EQ(colorGamut, GRAPHIC_COLOR_DISPLAY_P3); + + infoSet.primaries = COLORPRIMARIES_BT2020; + retSet = MetadataHelper::SetColorSpaceInfo(buffer, infoSet); + EXPECT_EQ(ret, GSERROR_OK); + colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, false); + EXPECT_EQ(colorGamut, GRAPHIC_COLOR_DISPLAY_P3); + + retSet = MetadataHelper::SetColorSpaceInfo(buffer, infoSet); + EXPECT_EQ(ret, GSERROR_OK); + colorGamut = hardwareThread.ComputeTargetColorGamut(buffer, true); + EXPECT_EQ(colorGamut, COLORPRIMARIES_BT2020); } /*