From f0a89c80228b1659a09bddfc69f93598903f4114 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Tue, 22 Jul 2025 01:51:46 +0000 Subject: [PATCH 01/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../irs_render_layer_processor_manager.h | 36 +++ .../include/rs_layer_compositor.h | 50 ++++ .../include/rs_layer_compositor_context.h | 77 ++++++ .../include/rs_render_layer_processor.h | 59 +++++ .../rs_render_layer_processor_manager.h | 55 +++++ .../rs_render_layer_processor_manager_proxy.h | 38 +++ .../composer/layer_processor/src/adaption.txt | 15 ++ .../src/rs_layer_compositor.cpp | 224 ++++++++++++++++++ .../src/rs_layer_compositor_context.cpp | 153 ++++++++++++ .../src/rs_render_layer_processor.cpp | 87 +++++++ .../src/rs_render_layer_processor_manager.cpp | 102 ++++++++ ...s_render_layer_processor_manager_proxy.cpp | 62 +++++ 12 files changed, 958 insertions(+) create mode 100644 rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h create mode 100644 rosen/modules/composer/layer_processor/include/rs_layer_compositor.h create mode 100644 rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h create mode 100644 rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h create mode 100644 rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h create mode 100644 rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h create mode 100644 rosen/modules/composer/layer_processor/src/adaption.txt create mode 100644 rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp create mode 100644 rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp create mode 100644 rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp create mode 100644 rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp create mode 100644 rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp diff --git a/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h b/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h new file mode 100644 index 0000000000..067cf10dbe --- /dev/null +++ b/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2025-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 IRS_RENDER_LAYER_PROCESSOR_MANAGER_H +#define IRS_RENDER_LAYER_PROCESSOR_MANAGER_H + +#include "rs_render_layer_processor.h" + +namespace OHOS::Rosen { +class IRSRenderLayerProcessorManager { +public: + IRSRenderLayerProcessorManager() = default; + virtual ~IRSRenderLayerProcessorManager() = default; + virtual void Start() = 0; + virtual void CreateRenderLayerProcessor(OutputPtr& output) = 0; + virtual void DestroyRenderLayerProcessor(OutputPtr& output) = 0; + virtual std::shared_ptr GetRenderLayerProcessor(ScreenId screenId) = 0; + virtual void PostTask(const std::function& task) = 0; + virtual void PostSyncTask(const std::function& task) = 0; + virtual void PostDelayTask(const std::function& task, int64_t delayTime) = 0; +} +} // namespace OHOS +#endif // IRS_RENDER_LAYER_PROCESSOR_MANAGER_H diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h b/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h new file mode 100644 index 0000000000..2cc49e6b4c --- /dev/null +++ b/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2025-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 RS_LAYER_COMPOSITOR_H +#define RS_LAYER_COMPOSITOR_H + +#include "rs_layer_compisitor_context.h" + +namespace OHOS::Rosen { +using UniFallbackCallback = std::function& surface, const std::vector& layers, + uint32_t screenId)>; +class RSLayerCompositor { +public: + RSLayerCompositor(OutputPtr output); + ~RSLayerCompositor() = default; + + // 维护layer + void AddRenderLayer(NodeId layerId); + void UpdateRenderLayer(NodeId layerId); + void DeleteRenderLayer(NodeId layerId); + + // 合成 + void PrepareComposeFrame(); + void ProcessComposeFrame(); + void CompleteComposeFrame(); + + std::shared_ptr GetLayerCompositorContext(); + void UpdateDelayTime(int64_t& delayTime); + void DimensionalInfoCollect(); +private: + void init(OutputPtr output); + void Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId); + void OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data); + std::shared_ptr layerCompositorContext_; + UniFallbackCallback redrawCb_; +} +} // namespace OHOS +#endif // RS_LAYER_COMPOSITOR_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h b/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h new file mode 100644 index 0000000000..ae43c0cb7d --- /dev/null +++ b/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2025-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 RS_LAYER_COMPOSITOR_CONTEXT_H +#define RS_LAYER_COMPOSITOR_CONTEXT_H + +#include +#include "hdi_backend.h" +#include "feature/hyper_graphic_manager/hgm_hardware_utils.h" +#include "rs_render_layer.h" + +namespace OHOS::Rosen { +using OutputPtr = std::shared_ptr; +class RSLayerCompositorContext { +public: + RSLayerCompositorContext(OutputPtr output); + ~RSLayerCompositorContext() = default; + + // 维护layer + void AddRenderLayer(NodeId layerId); + void UpdateRenderLayer(NodeId layerId); + void DeleteRenderLayer(NodeId layerId); + + std::unordered_map> GetLayersMap(); + HdiBackend* GetHdiBackend(); + OutputPtr GetOutput(); + std::shared_ptr GetHgmHardwareUtils(); + int32_t GetThreadId(); + int64_t GetDelayTime(); + void SetDelayTime(int64_t delayTime); + RSTimer& GetRSTime(); + void SetRSTime(RSTimer& rsTimer); + std::shared_ptr GetUniRenderEngine(); + ScreenId GetScreenId(); + uint32_t GetCurrentRate(); + void SetCurrentRate(); + bool GetHasGameScene(); + void SetHasGameScene(bool hasGameScene); + uint32_t GetUnExecuteTaskNum(); + void IncUnExecuteTaskNum(); + void SubUnExecuteTaskNum(); + int64_t GetLastCommitTime(); + void SetLastCommitTime(int64_t lastCommitTime); + void SetHgmCore(HgmCore& hgmCore); + HgmCore& GetHgmCore(); + +private: + std::unordered_map> layersMap_; + HdiBackend* hdiBackend_ = nullptr; + OutputPtr hdiOutput_; + std::shared_ptr uniRenderEngine_; + std::shared_ptr hgmHardwareUtils_; + ScreenId screenId_; + int64_t delayTime_ = 0; + int32_t threadTid_ = -1; + RSTimer rsTimer_; + HgmCore& hgmCore_; + uint32_t currentRate_ = 0; + bool hasGameScene_; + std::atomic unExecuteTaskNum_ = 0; + int64_t lastCommitTime_ = 0; +} +} // namespace OHOS +#endif // RS_LAYER_COMPOSITOR_CONTEXT_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h new file mode 100644 index 0000000000..8b0120b29e --- /dev/null +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2025-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 RS_RENDER_LAYER_PROCESSOR_H +#define RS_RENDER_LAYER_PROCESSOR_H + +#include +#include "event_handler.h" +#include "event_handler.h" +#include "rs_screen_manager.h" +#include "rs_layer_compositor.h" + +namespace OHOS::Rosen { +enum ProcessLayerType { + ADD_COMPOSE_LAYER, + UPDATE_COMPOSE_LAYER, + DELETE_COMPOSE_LAYER, +}; +class ScheduledTask; +class RSRenderLayerProcessor { +public: + RSRenderLayerProcessor(OutputPtr output); + ~RSRenderLayerProcessor() = default; + void Start(); + std::future ScheduleTask(Task&& task) + { + auto [scheduledTask, taskFuture] = Detail::ScheduledTask::Create(std::forward(task)); +#ifdef RS_ENABLE_GPU + PostTask([t(std::move(scheduledTask))]() { t->Run(); }); +#endif + return std::move(taskFuture); + } + void PostTask(const std::function& task); + void PostSyncTask(const std::function& task); + void PostDelayTask(const std::function& task, int64_t delayTime); + void ProcessLayerPostTask(ProcessLayerType layerType, NodeId layerId); + void DoComposeFramePostTask(); + +private: + std::shared_ptr runner_ = nullptr; + std::shared_ptr handler_ = nullptr; + std::shared_ptr layerCompositor_; + OutputPtr output_; +} +} // namespace OHOS +#endif // RS_RENDER_LAYER_PROCESSOR_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h new file mode 100644 index 0000000000..fd62717ea9 --- /dev/null +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2025-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 RS_RENDER_LAYER_PROCESSOR_MANAGER_H +#define RS_RENDER_LAYER_PROCESSOR_MANAGER_H + +#include "rs_render_layer_processor.h" + +namespace OHOS::Rosen { +class RSRenderLayerProcessorManager : public IRSRenderLayerProcessorManager { +public: + static RSRenderLayerProcessorManager& GetInstance(); + + void Start() override + void CreateRenderLayerProcessor(OutputPtr& output) override; + void DestroyRenderLayerProcessor(OutputPtr& output) override; + std::shared_ptr GetRenderLayerProcessor(ScreenId screenId) override; + void PostTask(const std::function& task) override; + void PostSyncTask(const std::function& task) override; + void PostDelayTask(const std::function& task, int64_t delayTime) override; + void PostLayerProcessorTask(const std::function& task, + std::shared_ptr layerProcess, bool isSyncTask) override; + void PostLayerProcessorDelayTask(const std::function& task, + std::shared_ptr layerProcess, int64_t delayTime) override; + void DumpInfo(DfxString& log); + +private: + RSRenderLayerProcessorManager() = default; + ~RSRenderLayerProcessorManager() = default; + RSRenderLayerProcessorManager(const RSRenderLayerProcessorManager &) = delete; + RSRenderLayerProcessorManager(const RSRenderLayerProcessorManager &&) = delete; + RSRenderLayerProcessorManager &operator = (const RSRenderLayerProcessorManager &) = delete; + RSRenderLayerProcessorManager &operator = (const RSRenderLayerProcessorManager &&) = delete; + + std::unordered_map> layerProcessorMap_; + std::shared_ptr runner_ = nullptr; + std::shared_ptr handler_ = nullptr; + std::mutex mutex_; + int32_t tid_; +} +} // namespace OHOS +#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h new file mode 100644 index 0000000000..3df9d074b2 --- /dev/null +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2025-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 RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H +#define RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H + +#include "rs_render_layer_processor.h" + +namespace OHOS::Rosen { +class RSRenderLayerProcessorManagerProxy { +public: + RSRenderLayerProcessorManagerProxy(); + ~RSRenderLayerProcessorManagerProxy() = default; + void Start() override; + void CreateRenderLayerProcessor(OutputPtr& output) override; + void DestroyRenderLayerProcessor(OutputPtr& output) override; + std::shared_ptr GetRenderLayerProcessor(ScreenId screenId) override; + void PostTask(const std::function& task) override; + void PostSyncTask(const std::function& task) override; + void PostDelayTask(const std::function& task, int64_t delayTime) override; +prvate: + RSRenderLayerProcessorManager& rsRenderLayerProcessorManager_; +} +} // namespace OHOS +#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/adaption.txt b/rosen/modules/composer/layer_processor/src/adaption.txt new file mode 100644 index 0000000000..63323e74d4 --- /dev/null +++ b/rosen/modules/composer/layer_processor/src/adaption.txt @@ -0,0 +1,15 @@ +1、vulkancontext单例 +if (RSSystemProperties::IsUseVulkan()) { + RsVulkanContext::GetSingleton().SetIsProtected(false); +} + +2、screenmanager初始化 +auto screenManager = CreateOrGetScreenManager(); +if (screenManager == nullptr || !screenManager->Init()) { + RS_LOGE("RSHardwareThread CreateOrGetScreenManager or init fail."); + return; +} + +3、vulkancontext单例 +// posttask for multithread safely release surface and image +ContextRegisterPostTask(); \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp new file mode 100644 index 0000000000..71cdd60217 --- /dev/null +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2025-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 "rs_layer_compositor.h" +#include "platform/common/rs_log.h" +#include "rs_trace.h" + +namespace OHOS { +namespace Rosen { +namespace { +// Threshold for abnormal time in the hardware pipeline +constexpr int HARDWARE_TIMEOUT = 800; +} + +RSLayerCompositor::RSLayerCompositor(OutputPtr output) +{ + init(output); +} + +void RSLayerCompositor::init(OutputPtr output) +{ + layerCompositorContext_ = std::make_shared(output); + redrawCb_ = [this](const sptr& surface, const std::vector& layers, uint32_t screenId) { + return this->Redraw(surface, layers, screenId); + }; + + // 需适配 + { +#if defined (RS_ENABLE_VK) + // Change vk interface type from UNIRENDER into UNPROTECTED_REDRAW, this is necessary for hardware init. + if (RSSystemProperties::IsUseVulkan()) { + RsVulkanContext::GetSingleton().SetIsProtected(false); + } +#endif + } + uniRenderEngine = layerCompositorContext_->GetUniRenderEngine(); + uniRenderEngine->Init(); + + // 需适配 + { + // posttask for multithread safely release surface and image + ContextRegisterPostTask(); + } + + auto onPrepareCompleteFunc = [this](auto& surface, const auto& param, void* data) { + OnPrepareComplete(surface, param, data); + }; + + auto hdiBackend = layerCompositorContext_->GetHdiBackend(); + if (hdiBackend != nullptr) { + hdiBackend->RegPrepareComplete(onPrepareCompleteFunc, this); + } + auto hgmHardwareUtils = layerCompositorContext_->GetHgmHardwareUtils(); + hgmHardwareUtils->RegisterChangeDssRefreshRateCb(); +} + +void RSLayerCompositor::AddRenderLayer(NodeId layerId) +{ + +} + +void RSLayerCompositor::UpdateRenderLayer(NodeId layerId) +{ + +} + +void RSLayerCompositor::DeleteRenderLayer(NodeId layerId) +{ + +} + +void RSLayerCompositor::PrepareComposeFrame() +{ + layerCompositorContext_->SetDelayTime(0); + std::string threadName = "Hardware_" + std::to_string(layerCompositorContext_->GetScreenId()); + RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); + layerCompositorContext_->SetRSTime(rsTimer); + // 需适配 + { + LayerComposeCollection::GetInstance().UpdateUniformOrOfflineComposeFrameNumberForDFX( + layerCompositorContext_->GetLayersMap()->size()); + } + hgmHardwareUtils_.UpdateRefreshRateParam(); + RefreshRateParam param = hgmHardwareUtils_.GetRefreshRateParam(); + // 需适配 + { + auto& hgmCore = OHOS::Rosen::HgmCore::Instance(); + ScreenId curScreenId = hgmCore.GetActiveScreenId(); + uint32_t currentRate = hgmCore.GetScreenCurrentRefreshRate(curScreenId); + layerCompositorContext_->SetHgmCore(hgmCore); + layerCompositorContext_->SetCurrentRate(currentRate); + bool hasGameScene = FrameReport::GetInstance().HasGameScene(); + layerCompositorContext_->SetHasGameScene(hasGameScene); +#ifdef RES_SCHED_ENABLE + ResschedEventListener::GetInstance()->ReportFrameToRSS(); +#endif + } +} + +void RSLayerCompositor::ProcessComposeFrame() +{ + +} + +void RSLayerCompositor::CompleteComposeFrame() +{ + +} + +void RSLayerCompositor::DimensionalInfoCollect() +{ + // 需适配 + { + RSBaseRenderUtil::IncAcquiredBufferCount(); + layerCompositorContext_->IncUnExecuteTaskNum(); + RSMainThread::Instance()->SetHardwareTaskNum(layerCompositorContext_->GetUnExecuteTaskNum()); + } +} + +bool RSLayerCompositor::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, + const OutputPtr& output, bool hasGameScene) +{ + if (param.isForceRefresh) { + RS_LOGD("CommitAndReleaseLayers in Force Refresh"); + RS_TRACE_NAME("CommitAndReleaseLayers in Force Refresh"); + return false; + } + + if (hgmCore.GetLtpoEnabled()) { + if (AdaptiveModeStatus(output) == SupportASStatus::SUPPORT_AS) { + RS_LOGD("CommitAndReleaseLayers in Adaptive Mode"); + RS_TRACE_NAME("CommitAndReleaseLayers in Adaptive Mode"); + return false; + } + if (hasGameScene && AdaptiveModeStatus(output) == SupportASStatus::GAME_SCENE_SKIP) { + RS_LOGD("CommitAndReleaseLayers skip delayTime Calculation"); + RS_TRACE_NAME("CommitAndReleaseLayers in Game Scene and skiped delayTime Calculation"); + return false; + } + } else { + if (!hgmCore.IsDelayMode()) { + return false; + } + if (hasGameScene) { + RS_LOGD("CommitAndReleaseLayers in Game Scene"); + RS_TRACE_NAME("CommitAndReleaseLayers in Game Scene"); + return false; + } + } + return true; +} + +void RSLayerCompositor::UpdateDelayTime(int64_t& delayTime) +{ + RS_LOGI_IF(DEBUG_COMPOSER, "CommitAndReleaseData hgmCore's LtpoEnabled is %{public}d", hgmCore.GetLtpoEnabled()); + int64_t currTime = SystemTime(); + auto hgmCore = layerCompositorContext_->GetHgmCore(); + auto output = layerCompositorContext_->GetOutput(); + if (IsDelayRequired(hgmCore, param, output, hasGameScene)) { + CalculateDelayTime(hgmCore, param, currentRate, currTime); + } + + // We need to ensure the order of composition frames, postTaskTime(n + 1) must > postTaskTime(n), + // and we give a delta time more between two composition tasks. + int64_t currCommitTime = currTime + delayTime_ * NS_MS_UNIT_CONVERSION; + auto lastCommitTime = layerCompositorContext_->GetLastCommitTime(); + auto delayTime; + if (currCommitTime <= lastCommitTime) { + delayTime = layerCompositorContext_->GetDelayTime(); + delayTime = delayTime + + std::round((lastCommitTime - currCommitTime) * 1.0f / NS_MS_UNIT_CONVERSION) + + COMMIT_DELTA_TIME; + RS_LOGD("CommitAndReleaseLayers vsyncId: %{public}" PRIu64 ", " \ + "update delayTime: %{public}" PRId64 ", currCommitTime: %{public}" PRId64 ", " \ + "lastCommitTime: %{public}" PRId64, param.vsyncId, delayTime, currCommitTime, lastCommitTime); + RS_TRACE_NAME_FMT("update delayTime: %" PRId64 ", currCommitTime: %" PRId64 ", lastCommitTime: %" PRId64 "", + delayTime, currCommitTime, lastCommitTime); + layerCompositorContext_->SetDelayTime(delayTime); + } + delayTime = layerCompositorContext_->GetDelayTime(); + if (delayTime < 0 || delayTime >= MAX_DELAY_TIME) { + layerCompositorContext_->SetDelayTime(0); + } + delayTime = layerCompositorContext_->GetDelayTime(); + layerCompositorContext_->SetLastCommitTime(currTime + delayTime * NS_MS_UNIT_CONVERSION); +} + +std::shared_ptr RSLayerCompositor::GetLayerCompositorContext() +{ + return layerCompositorContext_; +} + +void RSLayerCompositor::Redraw(const sptr& surface, const std::vector& layers, + uint32_t screenId) +{ + +} + +void RSLayerCompositor::OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data) +{ + // unused data. + (void)(data); + + if (!param.needFlushFramebuffer) { + return; + } + + if (redrawCb_ != nullptr) { + redrawCb_(surface, param.layers, param.screenId); + } +} +} // namespace Rosen +} // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp new file mode 100644 index 0000000000..68a48fb31d --- /dev/null +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2025-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 "rs_layer_conpositor_context.h" + +namespace OHOS { +namespace Rosen { +RSLayerCompositorContext::RSLayerCompositorContext(OutputPtr output) : hdiOutput_(output) +{ + screenId_ = output->GetScreenId(); + hdiBackend_ = HdiBackend::GetInstance(); + uniRenderEngine_ = std::make_shared(); + hgmHardwareUtils_ = std::make_shared(); + threadTid_ = gettid(); +} + +void RSLayerCompositorContext::AddRenderLayer(NodeId layerId) +{ + +} + +void RSLayerCompositorContext::UpdateRenderLayer(NodeId layerId) +{ + +} + +void RSLayerCompositorContext::DeleteRenderLayer(NodeId layerId) +{ + +} + +std::unordered_map> RSLayerCompositorContext::GetLayersMap() +{ + return layersMap_; +} + +HdiBackend* RSLayerCompositorContext::GetHdiBackend() +{ + return hdiBackend_; +} + +OutputPtr RSLayerCompositorContext::GetOutput() +{ + return hdiOutput_; +} + +std::shared_ptr RSLayerCompositorContext::GetHgmHardwareUtils() +{ + return hgmHardwareUtils_; +} + +int32_t RSLayerCompositorContext::GetThreadId() +{ + return threadTid_; +} + +int64_t RSLayerCompositorContext::GetDelayTime() +{ + return delayTime_; +} + +void RSLayerCompositorContext::SetDelayTime(int64_t delayTime) +{ + delayTime_ = delayTime; +} + +RSTimer& RSLayerCompositorContext::GetRSTime() +{ + return rsTimer_; +} + +void RSLayerCompositorContext::SetRSTime(RSTimer& rsTimer) +{ + rsTimer_ = rsTimer; +} + +std::shared_ptr RSLayerCompositorContext::GetUniRenderEngine() +{ + return uniRenderEngine_; +} + +ScreenId RSLayerCompositorContext::GetScreenId() +{ + return screenId_; +} + +uint32_t RSLayerCompositorContext::GetCurrentRate() +{ + return currentRate_; +} + +void RSLayerCompositorContext::SetCurrentRate(uint32_t currentRate) +{ + currentRate_ = currentRate; +} + +bool RSLayerCompositorContext::GetHasGameScene() +{ + return hasGameScene_; +} + +void RSLayerCompositorContext::SetHasGameScene(bool hasGameScene) +{ + hasGameScene_ = hasGameScene; +} + +uint32_t RSLayerCompositorContext::GetUnExecuteTaskNum() +{ + return unExecuteTaskNum_.load(); +} + +void RSLayerCompositorContext::IncUnExecuteTaskNum() +{ + unExecuteTaskNum_.fetch_add(1); +} + +void RSLayerCompositorContext::SubUnExecuteTaskNum() +{ + unExecuteTaskNum_.fetch_sub(1); +} + +int64_t RSLayerCompositorContext::GetLastCommitTime() +{ + return lastCommitTime_; +} + +void RSLayerCompositorContext::SetLastCommitTime(int64_t lastCommitTime) +{ + lastCommitTime_ = lastCommitTime; +} + +void RSLayerCompositorContext::SetHgmCore(HgmCore& hgmCore) +{ + hgmCore_ = hgmCore; +} + +HgmCore& RSLayerCompositorContext::GetHgmCore() +{ + return hgmCore_; +} +} // namespace Rosen +} // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp new file mode 100644 index 0000000000..558418a249 --- /dev/null +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2025-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 "rs_render_layer_processor.h" +#include "platform/common/rs_log.h" +#include "rs_trace.h" + +namespace OHOS { +namespace Rosen { +RSRenderLayerProcessor::RSRenderLayerProcessor(OutputPtr output) : output_(output) {} + +void RSRenderLayerProcessor::Start() +{ + RS_LOGI("Start RSRenderLayerProcessor, screenId : %{public}u", output_->GetScreenId()); + std::string threadName = "RSRenderLayerProcessor_" + std::to_string(output_->GetScreenId()); + runner_ = AppExecFwk::EventRunner::Create(threadName); + handler_ = std::make_shared(runner_); + + ScheduleTask([this]() { + layerCompositor_ = std::make_shared(output_); + }).wait();; +} + +void RSRenderLayerProcessor::PostTask(const std::function& task) +{ + if (handler_) { + handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} + +void RSRenderLayerProcessor::PostSyncTask(const std::function& task) +{ + if (handler_) { + handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} + +void RSRenderLayerProcessor::PostDelayTask(const std::function& task, int64_t delayTime) +{ + if (handler_) { + handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} + +void RSRenderLayerProcessor::ProcessLayerPostTask(ProcessLayerType layerType, NodeId layerId) +{ + std::function task = [this, layerType = layerType, layerId = layerId]() { + switch (layerType) { + case ADD_COMPOSE_LAYER: + layerCompositor_->AddRenderLayer(layerId); + break; + case UPDATE_COMPOSE_LAYER: + layerCompositor_->UpdateRenderLayer(layerId); + break; + case DELETE_COMPOSE_LAYER: + layerCompositor_->DeleteRenderLayer(layerId); + break; + default: + break; + } + }; + PostTask(task); +} + +void RSRenderLayerProcessor::DoComposeFramePostTask() +{ + layerCompositor_->PrepareComposeFrame(); + layerCompositor_->DimensionalInfoCollect(); + std::function task = [this]() { + layerCompositor_->ProceseComposeFrame(); + layerCompositor_->CompleteComposeFrame(); + }; + PostTask(task); +} +} // namespace Rosen +} // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp new file mode 100644 index 0000000000..042c7f4117 --- /dev/null +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2025-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 "rs_render_layer_processor_manager.h" +#include "platform/common/rs_log.h" +#include "rs_trace.h" + +namespace OHOS { +namespace Rosen { +RSRenderLayerProcessorManager& RSRenderLayerProcessorManager::GetInstance() +{ + static RSRenderLayerProcessorManager instance; + return instance; +} + +void RSRenderLayerProcessorManager::Start() +{ + RS_LOGI("Start RSRenderLayerProcessorManager"); + runner_ = AppExecFwk::EventRunner::Create("RSRenderLayerProcessorMainThread"); + handler_ = std::make_shared(runner_); + PostSyncTask([this]() { + // 向屏幕管理注册热插拔函数 + tid_ = gettid(); + }); +} + +void RSRenderLayerProcessorManager::CreateRenderLayerProcessor(OutputPtr& output) +{ + if (output == nullptr) { + return; + } + RS_LOGI("CreateRenderLayerProcessor screenId: %{public}u", output->GetScreenId()); + std::function task = [this, output = output]() { + auto layerProcessor = std::make_shared(output); + layerProcessor->Start(); + { + std::lock_guard lock(mutex_); + layerProcessorMap_.insert(std::pair(output->GetScreenId(), layerProcessor)); + } + }; + PostTask(task); +} + +void RSRenderLayerProcessorManager::DestroyRenderLayerProcessor(OutputPtr& output) +{ + if (output == nullptr) { + return; + } + RS_LOGI("DestroyRenderLayerProcessor screenId: %{public}u", output->GetScreenId()); + std::function task = [this, output = output]() { + { + std::lock_guard lock(mutex_); + layerProcessorMap_.erase(output->GetScreenId()); + } + }; + PostTask(task); +} + +std::shared_ptr RSRenderLayerProcessorManager::GetRenderLayerProcessor(ScreenId screenId) +{ + std::lock_guard lock(mutex_); + auto iter = layerProcessorMap_.find(screenId); + if (iter == layerProcessorMap_.end()) { + RS_LOGE("Not find screenId: %{public}u", screenId); + return nullptr; + } + return iter->sencond; +} + +void RSRenderLayerProcessorManager::PostTask(const std::function& task) +{ + if (handler_) { + handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} + +void RSRenderLayerProcessorManager::PostSyncTask(const std::function& task) +{ + if (handler_) { + handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} + +void RSRenderLayerProcessorManager::PostDelayTask(const std::function& task, int64_t delayTime) +{ + if (handler_) { + handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} +} // namespace Rosen +} // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp new file mode 100644 index 0000000000..f6bb387d51 --- /dev/null +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2025-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 "rs_render_layer_processor_manager_proxy.h" +#include "rs_render_layer_processor_manager.h" +#include "platform/common/rs_log.h" +#include "rs_trace.h" + +namespace OHOS { +namespace Rosen { +RSRenderLayerProcessorManagerProxy::RSRenderLayerProcessorManagerProxy() +{ + rsRenderLayerProcessorManager_ = RSRenderLayerProcessorManager::GetInstance(); +} + +void RSRenderLayerProcessorManagerProxy::Start() +{ + rsRenderLayerProcessorManager_.Start(); +} + +void RSRenderLayerProcessorManagerProxy::CreateRenderLayerProcessor(OutputPtr& output) +{ + rsRenderLayerProcessorManager_.CreateRenderLayerProcessor(output); +} + +void RSRenderLayerProcessorManagerProxy::DestroyRenderLayerProcessor(OutputPtr& output) +{ + rsRenderLayerProcessorManager_.DestroyRenderLayerProcessor(output); +} + +std::shared_ptr RSRenderLayerProcessorManagerProxy::GetRenderLayerProcessor(ScreenId screenId) +{ + return rsRenderLayerProcessorManager_.GetRenderLayerProcessor(screenId); +} + +void RSRenderLayerProcessorManagerProxy::PostTask(const std::function& task) +{ + rsRenderLayerProcessorManager_.PostTask(task); +} + +void RSRenderLayerProcessorManagerProxy::PostSyncTask(const std::function& task) +{ + rsRenderLayerProcessorManager_.PostSyncTask(task); +} + +void RSRenderLayerProcessorManagerProxy::PostDelayTask(const std::function& task, int64_t delayTime) +{ + rsRenderLayerProcessorManager_.PostDelayTask(task, delayTime); +} +} // namespace Rosen +} // namespace OHOS \ No newline at end of file -- Gitee From 5ee9952d1356829f2aa546cbb9744c4c57ddfaf7 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Tue, 22 Jul 2025 08:47:08 +0000 Subject: [PATCH 02/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../irs_render_layer_processor_manager.h | 12 +- .../include/rs_layer_compositor.h | 21 ++- .../include/rs_layer_compositor_context.h | 23 --- .../include/rs_render_layer_processor.h | 5 - .../rs_render_layer_processor_manager.h | 10 +- .../rs_render_layer_processor_manager_proxy.h | 9 +- .../src/rs_layer_compositor.cpp | 162 +++++++++++------- .../src/rs_layer_compositor_context.cpp | 75 -------- .../src/rs_render_layer_processor.cpp | 17 +- .../src/rs_render_layer_processor_manager.cpp | 18 ++ ...s_render_layer_processor_manager_proxy.cpp | 5 - 11 files changed, 169 insertions(+), 188 deletions(-) diff --git a/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h b/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h index 067cf10dbe..22d88c4051 100644 --- a/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h +++ b/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h @@ -17,9 +17,16 @@ #ifndef IRS_RENDER_LAYER_PROCESSOR_MANAGER_H #define IRS_RENDER_LAYER_PROCESSOR_MANAGER_H -#include "rs_render_layer_processor.h" +#include +#include "hdi_output.h" namespace OHOS::Rosen { +enum ProcessSubThreadTaskType { + ADD_COMPOSE_LAYER, + UPDATE_COMPOSE_LAYER, + DELETE_COMPOSE_LAYER, + DO_COMPOSER_FRAME, +}; class IRSRenderLayerProcessorManager { public: IRSRenderLayerProcessorManager() = default; @@ -27,10 +34,11 @@ public: virtual void Start() = 0; virtual void CreateRenderLayerProcessor(OutputPtr& output) = 0; virtual void DestroyRenderLayerProcessor(OutputPtr& output) = 0; - virtual std::shared_ptr GetRenderLayerProcessor(ScreenId screenId) = 0; virtual void PostTask(const std::function& task) = 0; virtual void PostSyncTask(const std::function& task) = 0; virtual void PostDelayTask(const std::function& task, int64_t delayTime) = 0; + template + virtual void DistributeTaskToSubThread(ProcessSubThreadTaskType taskType, T data) = 0; } } // namespace OHOS #endif // IRS_RENDER_LAYER_PROCESSOR_MANAGER_H diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h b/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h index 2cc49e6b4c..6e3f319353 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h +++ b/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h @@ -21,6 +21,7 @@ namespace OHOS::Rosen { using UniFallbackCallback = std::function& surface, const std::vector& layers, uint32_t screenId)>; +using OutputPtr = std::shared_ptr; class RSLayerCompositor { public: RSLayerCompositor(OutputPtr output); @@ -32,19 +33,29 @@ public: void DeleteRenderLayer(NodeId layerId); // 合成 - void PrepareComposeFrame(); - void ProcessComposeFrame(); + void PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, bool& hasGameScene, + ScreenId& curScreenId, int64_t& delayTime); + void ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId); void CompleteComposeFrame(); - std::shared_ptr GetLayerCompositorContext(); - void UpdateDelayTime(int64_t& delayTime); - void DimensionalInfoCollect(); private: void init(OutputPtr output); void Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId); void OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data); + void UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, + uint32_t currentRate, bool hasGameScene); + bool IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, + const OutputPtr& output, bool hasGameScene); + void CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, + uint32_t currentRate, int64_t currTime); + uint32_t GetUnExecuteTaskNum(); + void IncUnExecuteTaskNum(); + void SubUnExecuteTaskNum(); std::shared_ptr layerCompositorContext_; UniFallbackCallback redrawCb_; + int64_t delayTime_ = 0; + int64_t lastCommitTime_ = 0; + std::atomic unExecuteTaskNum_ = 0; } } // namespace OHOS #endif // RS_LAYER_COMPOSITOR_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h b/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h index ae43c0cb7d..d7c6fefae3 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h +++ b/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h @@ -23,7 +23,6 @@ #include "rs_render_layer.h" namespace OHOS::Rosen { -using OutputPtr = std::shared_ptr; class RSLayerCompositorContext { public: RSLayerCompositorContext(OutputPtr output); @@ -39,23 +38,8 @@ public: OutputPtr GetOutput(); std::shared_ptr GetHgmHardwareUtils(); int32_t GetThreadId(); - int64_t GetDelayTime(); - void SetDelayTime(int64_t delayTime); - RSTimer& GetRSTime(); - void SetRSTime(RSTimer& rsTimer); std::shared_ptr GetUniRenderEngine(); ScreenId GetScreenId(); - uint32_t GetCurrentRate(); - void SetCurrentRate(); - bool GetHasGameScene(); - void SetHasGameScene(bool hasGameScene); - uint32_t GetUnExecuteTaskNum(); - void IncUnExecuteTaskNum(); - void SubUnExecuteTaskNum(); - int64_t GetLastCommitTime(); - void SetLastCommitTime(int64_t lastCommitTime); - void SetHgmCore(HgmCore& hgmCore); - HgmCore& GetHgmCore(); private: std::unordered_map> layersMap_; @@ -64,14 +48,7 @@ private: std::shared_ptr uniRenderEngine_; std::shared_ptr hgmHardwareUtils_; ScreenId screenId_; - int64_t delayTime_ = 0; int32_t threadTid_ = -1; - RSTimer rsTimer_; - HgmCore& hgmCore_; - uint32_t currentRate_ = 0; - bool hasGameScene_; - std::atomic unExecuteTaskNum_ = 0; - int64_t lastCommitTime_ = 0; } } // namespace OHOS #endif // RS_LAYER_COMPOSITOR_CONTEXT_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h index 8b0120b29e..e20b0a8b05 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h @@ -24,11 +24,6 @@ #include "rs_layer_compositor.h" namespace OHOS::Rosen { -enum ProcessLayerType { - ADD_COMPOSE_LAYER, - UPDATE_COMPOSE_LAYER, - DELETE_COMPOSE_LAYER, -}; class ScheduledTask; class RSRenderLayerProcessor { public: diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h index fd62717ea9..f28ac7ab24 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h @@ -17,6 +17,7 @@ #ifndef RS_RENDER_LAYER_PROCESSOR_MANAGER_H #define RS_RENDER_LAYER_PROCESSOR_MANAGER_H +#include "irs_render_layer_processor_manager.h" #include "rs_render_layer_processor.h" namespace OHOS::Rosen { @@ -24,17 +25,14 @@ class RSRenderLayerProcessorManager : public IRSRenderLayerProcessorManager { public: static RSRenderLayerProcessorManager& GetInstance(); - void Start() override + void Start() override; void CreateRenderLayerProcessor(OutputPtr& output) override; void DestroyRenderLayerProcessor(OutputPtr& output) override; - std::shared_ptr GetRenderLayerProcessor(ScreenId screenId) override; void PostTask(const std::function& task) override; void PostSyncTask(const std::function& task) override; void PostDelayTask(const std::function& task, int64_t delayTime) override; - void PostLayerProcessorTask(const std::function& task, - std::shared_ptr layerProcess, bool isSyncTask) override; - void PostLayerProcessorDelayTask(const std::function& task, - std::shared_ptr layerProcess, int64_t delayTime) override; + template + void DistributeTaskToSubThread(ProcessLayerType taskType, T data) override; void DumpInfo(DfxString& log); private: diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h index 3df9d074b2..82542f47c0 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h @@ -17,20 +17,25 @@ #ifndef RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H #define RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H +#include "irs_render_layer_processor_manager.h" #include "rs_render_layer_processor.h" namespace OHOS::Rosen { -class RSRenderLayerProcessorManagerProxy { +class RSRenderLayerProcessorManagerProxy : public IRSRenderLayerProcessorManager { public: RSRenderLayerProcessorManagerProxy(); ~RSRenderLayerProcessorManagerProxy() = default; void Start() override; void CreateRenderLayerProcessor(OutputPtr& output) override; void DestroyRenderLayerProcessor(OutputPtr& output) override; - std::shared_ptr GetRenderLayerProcessor(ScreenId screenId) override; void PostTask(const std::function& task) override; void PostSyncTask(const std::function& task) override; void PostDelayTask(const std::function& task, int64_t delayTime) override; + template + void DistributeTaskToSubThread(ProcessSubThreadTaskType taskType, T data) override + { + rsRenderLayerProcessorManager_->DistributeTaskToSubThread(taskType, data); + } prvate: RSRenderLayerProcessorManager& rsRenderLayerProcessorManager_; } diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp index 71cdd60217..fc6ed1e4b9 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp @@ -36,22 +36,19 @@ void RSLayerCompositor::init(OutputPtr output) }; // 需适配 - { #if defined (RS_ENABLE_VK) - // Change vk interface type from UNIRENDER into UNPROTECTED_REDRAW, this is necessary for hardware init. - if (RSSystemProperties::IsUseVulkan()) { - RsVulkanContext::GetSingleton().SetIsProtected(false); - } -#endif + // Change vk interface type from UNIRENDER into UNPROTECTED_REDRAW, this is necessary for hardware init. + if (RSSystemProperties::IsUseVulkan()) { + RsVulkanContext::GetSingleton().SetIsProtected(false); } +#endif + uniRenderEngine = layerCompositorContext_->GetUniRenderEngine(); uniRenderEngine->Init(); // 需适配 - { - // posttask for multithread safely release surface and image - ContextRegisterPostTask(); - } + // posttask for multithread safely release surface and image + ContextRegisterPostTask(); auto onPrepareCompleteFunc = [this](auto& surface, const auto& param, void* data) { OnPrepareComplete(surface, param, data); @@ -80,37 +77,56 @@ void RSLayerCompositor::DeleteRenderLayer(NodeId layerId) } -void RSLayerCompositor::PrepareComposeFrame() +uint32_t RSLayerCompositor::GetUnExecuteTaskNum() +{ + return unExecuteTaskNum_.load(); +} + +void RSLayerCompositor::IncUnExecuteTaskNum() +{ + unExecuteTaskNum_.fetch_add(1); +} + +void RSLayerCompositor::SubUnExecuteTaskNum() +{ + unExecuteTaskNum_.fetch_sub(1); +} + +void RSLayerCompositor::PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, + bool& hasGameScene, ScreenId& curScreenId, int64_t& delayTime) { - layerCompositorContext_->SetDelayTime(0); - std::string threadName = "Hardware_" + std::to_string(layerCompositorContext_->GetScreenId()); - RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); - layerCompositorContext_->SetRSTime(rsTimer); // 需适配 - { - LayerComposeCollection::GetInstance().UpdateUniformOrOfflineComposeFrameNumberForDFX( - layerCompositorContext_->GetLayersMap()->size()); - } + LayerComposeCollection::GetInstance().UpdateUniformOrOfflineComposeFrameNumberForDFX( + layerCompositorContext_->GetLayersMap()->size()); + hgmHardwareUtils_.UpdateRefreshRateParam(); RefreshRateParam param = hgmHardwareUtils_.GetRefreshRateParam(); // 需适配 - { - auto& hgmCore = OHOS::Rosen::HgmCore::Instance(); - ScreenId curScreenId = hgmCore.GetActiveScreenId(); - uint32_t currentRate = hgmCore.GetScreenCurrentRefreshRate(curScreenId); - layerCompositorContext_->SetHgmCore(hgmCore); - layerCompositorContext_->SetCurrentRate(currentRate); - bool hasGameScene = FrameReport::GetInstance().HasGameScene(); - layerCompositorContext_->SetHasGameScene(hasGameScene); + auto hgmCore = OHOS::Rosen::HgmCore::Instance(); + curScreenId = hgmCore.GetActiveScreenId(); + currentRate = hgmCore.GetScreenCurrentRefreshRate(curScreenId); + hasGameScene = FrameReport::GetInstance().HasGameScene(); #ifdef RES_SCHED_ENABLE - ResschedEventListener::GetInstance()->ReportFrameToRSS(); + ResschedEventListener::GetInstance()->ReportFrameToRSS(); #endif - } + + // 需适配 + RSBaseRenderUtil::IncAcquiredBufferCount(); + IncUnExecuteTaskNum(); + RSMainThread::Instance()->SetHardwareTaskNum(GetUnExecuteTaskNum()); + + UpdateDelayTime(hgmCore, param, currentRate, hasGameScene); + delayTime = delayTime_; } -void RSLayerCompositor::ProcessComposeFrame() +void RSLayerCompositor::ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, + bool hasGameScene, ScreenId curScreenId) { + std::string threadName = "Hardware_" + std::to_string(layerCompositorContext_->GetScreenId()); + RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); + + EndCheck(timer); } void RSLayerCompositor::CompleteComposeFrame() @@ -118,14 +134,53 @@ void RSLayerCompositor::CompleteComposeFrame() } -void RSLayerCompositor::DimensionalInfoCollect() +void RSLayerCompositor::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, + int64_t currTime) { - // 需适配 - { - RSBaseRenderUtil::IncAcquiredBufferCount(); - layerCompositorContext_->IncUnExecuteTaskNum(); - RSMainThread::Instance()->SetHardwareTaskNum(layerCompositorContext_->GetUnExecuteTaskNum()); + int64_t frameOffset = 0; + int64_t vsyncOffset = 0; + int64_t idealPipelineOffset = 0; + int64_t pipelineOffset = 0; + int64_t expectCommitTime = 0; + int64_t periodNum = 0; + int64_t idealPeriod = hgmCore.GetIdealPeriod(currentRate); + int64_t period = CreateVSyncSampler()->GetHardwarePeriod(); + uint64_t dvsyncOffset = RSMainThread::Instance()->GetRealTimeOffsetOfDvsync(param.frameTimestamp); + int64_t compositionTime = period; + + if (!hgmCore.GetLtpoEnabled()) { + vsyncOffset = UNI_RENDER_VSYNC_OFFSET_DELAY_MODE; + // 2 period for draw and composition, pipelineOffset = 2 * period + frameOffset = 2 * period + vsyncOffset - static_cast(param.fastComposeTimeStampDiff); + } else { + idealPipelineOffset = hgmCore.GetIdealPipelineOffset(); + pipelineOffset = hgmCore.GetPipelineOffset(); + vsyncOffset = CreateVSyncGenerator()->GetVSyncOffset(); + periodNum = idealPeriod == 0 ? 0 : idealPipelineOffset / idealPeriod; + + if (vsyncOffset >= period) { + vsyncOffset = 0; + } + if (periodNum * idealPeriod + vsyncOffset + IDEAL_PULSE < idealPipelineOffset) { + periodNum = periodNum + 1; + } + frameOffset = periodNum * idealPeriod + vsyncOffset + + static_cast(dvsyncOffset) - static_cast(param.fastComposeTimeStampDiff); } + expectCommitTime = param.actualTimestamp + frameOffset - compositionTime - RESERVE_TIME; + int64_t diffTime = expectCommitTime - currTime; + if (diffTime > 0 && period > 0) { + delayTime_ = std::round(diffTime * 1.0f / NS_MS_UNIT_CONVERSION); + } + RS_TRACE_NAME_FMT("CalculateDelayTime pipelineOffset: %" PRId64 ", actualTimestamp: %" PRId64 ", " \ + "expectCommitTime: %" PRId64 ", currTime: %" PRId64 ", diffTime: %" PRId64 ", delayTime: %" PRId64 ", " \ + "frameOffset: %" PRId64 ", dvsyncOffset: %" PRIu64 ", vsyncOffset: %" PRId64 ", idealPeriod: %" PRId64 ", " \ + "period: %" PRId64 ", idealPipelineOffset: %" PRId64 ", fastComposeTimeStampDiff: %" PRIu64 "", + pipelineOffset, param.actualTimestamp, expectCommitTime, currTime, diffTime, delayTime_, + frameOffset, dvsyncOffset, vsyncOffset, idealPeriod, period, + idealPipelineOffset, param.fastComposeTimeStampDiff); + RS_LOGD_IF(DEBUG_PIPELINE, "CalculateDelayTime period:%{public}" PRId64 " delayTime:%{public}" PRId64 "", period, + delayTime_); } bool RSLayerCompositor::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, @@ -161,44 +216,33 @@ bool RSLayerCompositor::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRa return true; } -void RSLayerCompositor::UpdateDelayTime(int64_t& delayTime) +void RSLayerCompositor::UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, + uint32_t currentRate, bool hasGameScene) { + delayTime_ = 0; RS_LOGI_IF(DEBUG_COMPOSER, "CommitAndReleaseData hgmCore's LtpoEnabled is %{public}d", hgmCore.GetLtpoEnabled()); int64_t currTime = SystemTime(); - auto hgmCore = layerCompositorContext_->GetHgmCore(); - auto output = layerCompositorContext_->GetOutput(); - if (IsDelayRequired(hgmCore, param, output, hasGameScene)) { + if (IsDelayRequired(hgmCore, param, layerCompositorContext_->GetOutput(), hasGameScene)) { CalculateDelayTime(hgmCore, param, currentRate, currTime); } // We need to ensure the order of composition frames, postTaskTime(n + 1) must > postTaskTime(n), // and we give a delta time more between two composition tasks. int64_t currCommitTime = currTime + delayTime_ * NS_MS_UNIT_CONVERSION; - auto lastCommitTime = layerCompositorContext_->GetLastCommitTime(); - auto delayTime; - if (currCommitTime <= lastCommitTime) { - delayTime = layerCompositorContext_->GetDelayTime(); - delayTime = delayTime + - std::round((lastCommitTime - currCommitTime) * 1.0f / NS_MS_UNIT_CONVERSION) + + if (currCommitTime <= lastCommitTime_) { + delayTime_ = delayTime_ + + std::round((lastCommitTime_ - currCommitTime) * 1.0f / NS_MS_UNIT_CONVERSION) + COMMIT_DELTA_TIME; RS_LOGD("CommitAndReleaseLayers vsyncId: %{public}" PRIu64 ", " \ "update delayTime: %{public}" PRId64 ", currCommitTime: %{public}" PRId64 ", " \ - "lastCommitTime: %{public}" PRId64, param.vsyncId, delayTime, currCommitTime, lastCommitTime); + "lastCommitTime: %{public}" PRId64, param.vsyncId, delayTime_, currCommitTime, lastCommitTime_); RS_TRACE_NAME_FMT("update delayTime: %" PRId64 ", currCommitTime: %" PRId64 ", lastCommitTime: %" PRId64 "", - delayTime, currCommitTime, lastCommitTime); - layerCompositorContext_->SetDelayTime(delayTime); + delayTime_, currCommitTime, lastCommitTime_); } - delayTime = layerCompositorContext_->GetDelayTime(); - if (delayTime < 0 || delayTime >= MAX_DELAY_TIME) { - layerCompositorContext_->SetDelayTime(0); + if (delayTime_ < 0 || delayTime_ >= MAX_DELAY_TIME) { + delayTime_ = 0; } - delayTime = layerCompositorContext_->GetDelayTime(); - layerCompositorContext_->SetLastCommitTime(currTime + delayTime * NS_MS_UNIT_CONVERSION); -} - -std::shared_ptr RSLayerCompositor::GetLayerCompositorContext() -{ - return layerCompositorContext_; + lastCommitTime_ = currTime + delayTime_ * NS_MS_UNIT_CONVERSION; } void RSLayerCompositor::Redraw(const sptr& surface, const std::vector& layers, diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp index 68a48fb31d..9cb8f58848 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp @@ -65,26 +65,6 @@ int32_t RSLayerCompositorContext::GetThreadId() return threadTid_; } -int64_t RSLayerCompositorContext::GetDelayTime() -{ - return delayTime_; -} - -void RSLayerCompositorContext::SetDelayTime(int64_t delayTime) -{ - delayTime_ = delayTime; -} - -RSTimer& RSLayerCompositorContext::GetRSTime() -{ - return rsTimer_; -} - -void RSLayerCompositorContext::SetRSTime(RSTimer& rsTimer) -{ - rsTimer_ = rsTimer; -} - std::shared_ptr RSLayerCompositorContext::GetUniRenderEngine() { return uniRenderEngine_; @@ -94,60 +74,5 @@ ScreenId RSLayerCompositorContext::GetScreenId() { return screenId_; } - -uint32_t RSLayerCompositorContext::GetCurrentRate() -{ - return currentRate_; -} - -void RSLayerCompositorContext::SetCurrentRate(uint32_t currentRate) -{ - currentRate_ = currentRate; -} - -bool RSLayerCompositorContext::GetHasGameScene() -{ - return hasGameScene_; -} - -void RSLayerCompositorContext::SetHasGameScene(bool hasGameScene) -{ - hasGameScene_ = hasGameScene; -} - -uint32_t RSLayerCompositorContext::GetUnExecuteTaskNum() -{ - return unExecuteTaskNum_.load(); -} - -void RSLayerCompositorContext::IncUnExecuteTaskNum() -{ - unExecuteTaskNum_.fetch_add(1); -} - -void RSLayerCompositorContext::SubUnExecuteTaskNum() -{ - unExecuteTaskNum_.fetch_sub(1); -} - -int64_t RSLayerCompositorContext::GetLastCommitTime() -{ - return lastCommitTime_; -} - -void RSLayerCompositorContext::SetLastCommitTime(int64_t lastCommitTime) -{ - lastCommitTime_ = lastCommitTime; -} - -void RSLayerCompositorContext::SetHgmCore(HgmCore& hgmCore) -{ - hgmCore_ = hgmCore; -} - -HgmCore& RSLayerCompositorContext::GetHgmCore() -{ - return hgmCore_; -} } // namespace Rosen } // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp index 558418a249..c87e42bc7a 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp @@ -75,13 +75,18 @@ void RSRenderLayerProcessor::ProcessLayerPostTask(ProcessLayerType layerType, No void RSRenderLayerProcessor::DoComposeFramePostTask() { - layerCompositor_->PrepareComposeFrame(); - layerCompositor_->DimensionalInfoCollect(); - std::function task = [this]() { - layerCompositor_->ProceseComposeFrame(); - layerCompositor_->CompleteComposeFrame(); + RefreshRateParam param; + uint32_t currentRate; + bool hasGameScene; + ScreenId curScreenId; + int64_t delayTime = 0; + layerCompositor_->PrepareComposeFrame(param, currentRate, hasGameScene, curScreenId, delayTime); + + std::function task = [this, param = param, currentRate = currentRate, + hasGameScene = hasGameScene, curScreenId = curScreenId]() { + layerCompositor_->ProceseComposeFrame(param, currentRate, hasGameScene, curScreenId); }; - PostTask(task); + PostDelayTask(task, delayTime); } } // namespace Rosen } // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp index 042c7f4117..0cd606659c 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp @@ -98,5 +98,23 @@ void RSRenderLayerProcessorManager::PostDelayTask(const std::function& t handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } + +template +void RSRenderLayerProcessorManager::DistributeTaskToSubThread(ProcessLayerType taskType, T data) +{ + switch (taskType) + { + case ADD_COMPOSE_LAYER: + break; + case UPDATE_COMPOSE_LAYER: + break; + case DELETE_COMPOSE_LAYER: + break; + case DO_COMPOSER_FRAME; + break; + default: + break; + } +} } // namespace Rosen } // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp index f6bb387d51..b6e553b28b 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp @@ -39,11 +39,6 @@ void RSRenderLayerProcessorManagerProxy::DestroyRenderLayerProcessor(OutputPtr& rsRenderLayerProcessorManager_.DestroyRenderLayerProcessor(output); } -std::shared_ptr RSRenderLayerProcessorManagerProxy::GetRenderLayerProcessor(ScreenId screenId) -{ - return rsRenderLayerProcessorManager_.GetRenderLayerProcessor(screenId); -} - void RSRenderLayerProcessorManagerProxy::PostTask(const std::function& task) { rsRenderLayerProcessorManager_.PostTask(task); -- Gitee From 72cd6cadc3df56adf5c55618b197a5692839d8ae Mon Sep 17 00:00:00 2001 From: m00472246 Date: Tue, 22 Jul 2025 11:19:46 +0000 Subject: [PATCH 03/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../include/rs_layer_compositor.h | 6 + .../include/rs_layer_compositor_context.h | 7 +- ...s_render_layer_processor_manager_agency.h} | 12 +- .../src/rs_layer_compositor.cpp | 158 +++++++++++++++++- .../src/rs_layer_compositor_context.cpp | 7 +- ...render_layer_processor_manager_agency.cpp} | 16 +- 6 files changed, 188 insertions(+), 18 deletions(-) rename rosen/modules/composer/layer_processor/include/{rs_render_layer_processor_manager_proxy.h => rs_render_layer_processor_manager_agency.h} (80%) rename rosen/modules/composer/layer_processor/src/{rs_render_layer_processor_manager_proxy.cpp => rs_render_layer_processor_manager_agency.cpp} (67%) diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h b/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h index 6e3f319353..ccce61b92c 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h +++ b/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h @@ -16,6 +16,7 @@ #ifndef RS_LAYER_COMPOSITOR_H #define RS_LAYER_COMPOSITOR_H +#include #include "rs_layer_compisitor_context.h" namespace OHOS::Rosen { @@ -48,14 +49,19 @@ private: const OutputPtr& output, bool hasGameScene); void CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, int64_t currTime); + int32_t AdaptiveModeStatus(const OutputPtr &output); + void EndCheck(RSTimer timer); uint32_t GetUnExecuteTaskNum(); void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); + std::shared_ptr layerCompositorContext_; UniFallbackCallback redrawCb_; int64_t delayTime_ = 0; int64_t lastCommitTime_ = 0; std::atomic unExecuteTaskNum_ = 0; + int hardwareCount_ = 0; + ExceptionCheck exceptionCheck_; } } // namespace OHOS #endif // RS_LAYER_COMPOSITOR_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h b/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h index d7c6fefae3..4aee6665ed 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h +++ b/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h @@ -17,9 +17,10 @@ #ifndef RS_LAYER_COMPOSITOR_CONTEXT_H #define RS_LAYER_COMPOSITOR_CONTEXT_H -#include #include "hdi_backend.h" +#include "hdi_layer.h" #include "feature/hyper_graphic_manager/hgm_hardware_utils.h" +#include "pipeline/render_thread/rs_uni_render_engine.h" #include "rs_render_layer.h" namespace OHOS::Rosen { @@ -33,7 +34,8 @@ public: void UpdateRenderLayer(NodeId layerId); void DeleteRenderLayer(NodeId layerId); - std::unordered_map> GetLayersMap(); + std::unordered_map>& GetLayersMap(); + std::vector& GetLayersVec(); HdiBackend* GetHdiBackend(); OutputPtr GetOutput(); std::shared_ptr GetHgmHardwareUtils(); @@ -43,6 +45,7 @@ public: private: std::unordered_map> layersMap_; + std::vector layersVec_; HdiBackend* hdiBackend_ = nullptr; OutputPtr hdiOutput_; std::shared_ptr uniRenderEngine_; diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_agency.h similarity index 80% rename from rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h rename to rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_agency.h index 82542f47c0..2c450ed5ac 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_proxy.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_agency.h @@ -14,17 +14,17 @@ * limitations under the License. */ -#ifndef RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H -#define RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H +#ifndef RS_RENDER_LAYER_PROCESSOR_MANAGER_AGENCY_H +#define RS_RENDER_LAYER_PROCESSOR_MANAGER_AGENCY_H #include "irs_render_layer_processor_manager.h" #include "rs_render_layer_processor.h" namespace OHOS::Rosen { -class RSRenderLayerProcessorManagerProxy : public IRSRenderLayerProcessorManager { +class RSRenderLayerProcessorManagerAgency : public IRSRenderLayerProcessorManager { public: - RSRenderLayerProcessorManagerProxy(); - ~RSRenderLayerProcessorManagerProxy() = default; + RSRenderLayerProcessorManagerAgency(); + ~RSRenderLayerProcessorManagerAgency() = default; void Start() override; void CreateRenderLayerProcessor(OutputPtr& output) override; void DestroyRenderLayerProcessor(OutputPtr& output) override; @@ -40,4 +40,4 @@ prvate: RSRenderLayerProcessorManager& rsRenderLayerProcessorManager_; } } // namespace OHOS -#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_PROXY_H \ No newline at end of file +#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_AGENCY_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp index fc6ed1e4b9..967ef41549 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp @@ -13,14 +13,32 @@ * limitations under the License. */ #include "rs_layer_compositor.h" +#include +#include +#include "common/rs_exception_check.h" +#include "hgm_core.h" #include "platform/common/rs_log.h" #include "rs_trace.h" +#include "vsync_sampler.h" namespace OHOS { namespace Rosen { namespace { // Threshold for abnormal time in the hardware pipeline constexpr int HARDWARE_TIMEOUT = 800; +// The number of exceptions in the hardware pipeline required to achieve render_service reset +constexpr int HARDWARE_TIMEOUT_ABORT_CNT = 30; +// The number of exceptions in the hardware pipeline required to report hisysevent +constexpr int HARDWARE_TIMEOUT_CNT = 15; +const std::string PROCESS_NAME_FOR_HISYSEVENT = "/system/bin/render_service"; +const std::string HARDWARE_PIPELINE_TIMEOUT = "hardware_pipeline_timeout"; +} + +static int64_t SystemTime() +{ + timespec t = {}; + clock_gettime(CLOCK_MONOTONIC, &t); + return int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec; // 1000000000ns == 1s } RSLayerCompositor::RSLayerCompositor(OutputPtr output) @@ -100,7 +118,7 @@ void RSLayerCompositor::PrepareComposeFrame(RefreshRateParam& param, uint32_t& c layerCompositorContext_->GetLayersMap()->size()); hgmHardwareUtils_.UpdateRefreshRateParam(); - RefreshRateParam param = hgmHardwareUtils_.GetRefreshRateParam(); + param = hgmHardwareUtils_.GetRefreshRateParam(); // 需适配 auto hgmCore = OHOS::Rosen::HgmCore::Instance(); curScreenId = hgmCore.GetActiveScreenId(); @@ -119,12 +137,125 @@ void RSLayerCompositor::PrepareComposeFrame(RefreshRateParam& param, uint32_t& c delayTime = delayTime_; } +void RSLayerCompositor::EndCheck(RSTimer timer) +{ + exceptionCheck_.pid_ = getpid(); + exceptionCheck_.uid_ = getuid(); + exceptionCheck_.processName_ = PROCESS_NAME_FOR_HISYSEVENT; + exceptionCheck_.exceptionPoint_ = HARDWARE_PIPELINE_TIMEOUT; + + if (timer.GetDuration() >= HARDWARE_TIMEOUT) { + if (++hardwareCount_ == HARDWARE_TIMEOUT_CNT) { + RS_LOGE("Hardware Thread Exception Count[%{public}d]", hardwareCount_); + exceptionCheck_.exceptionCnt_ = hardwareCount_; + exceptionCheck_.exceptionMoment_ = timer.GetSeconds(); + exceptionCheck_.UploadRenderExceptionData(); + } + } else { + hardwareCount_ = 0; + } + if (hardwareCount_ == HARDWARE_TIMEOUT_ABORT_CNT) { + exceptionCheck_.exceptionCnt_ = hardwareCount_; + exceptionCheck_.exceptionMoment_ = timer.GetSeconds(); + exceptionCheck_.UploadRenderExceptionData(); + sleep(1); // sleep 1s : abort will kill RS, sleep 1s for hisysevent report. + abort(); // The RS process needs to be restarted because 30 consecutive frames in hardware times out. + } +} + void RSLayerCompositor::ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId) { std::string threadName = "Hardware_" + std::to_string(layerCompositorContext_->GetScreenId()); RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); + layerCompositorContext_-> +ifdef HIPERF_TRACE_ENABLE + RS_LOGW("hiperf_surface_counter3 %{public}" PRIu64 " ", static_cast(layers.size())); +#endif + int64_t startTime = GetCurTimeCount(); + std::string surfaceName = GetSurfaceNameInLayers(layers); + RS_LOGD("CommitAndReleaseLayers task execute, %{public}s", surfaceName.c_str()); + if (output == nullptr || hdiBackend_ == nullptr) { + RS_LOGI("CommitAndReleaseLayers task return, %{public}s", surfaceName.c_str()); + return; + } + int64_t startTimeNs = 0; + int64_t endTimeNs = 0; + + RSFirstFrameNotifier::GetInstance().ExecIfFirstFrameCommit(output->GetScreenId()); + + RS_LOGI_IF(DEBUG_COMPOSER, "CommitAndReleaseData hasGameScene is %{public}d %{public}s", + hasGameScene, surfaceName.c_str()); + if (hasGameScene) { + startTimeNs = std::chrono::duration_cast( + std::chrono::steady_clock::now().time_since_epoch()).count(); + } + RS_TRACE_NAME_FMT("CommitLayers rate:%u,now:%" PRIu64 ",vsyncId:%" PRIu64 ",size:%zu,%s", + currentRate, param.frameTimestamp, param.vsyncId, layers.size(), + GetSurfaceNameInLayersForTrace(layers).c_str()); + RS_LOGD("CommitLayers rate:%{public}u, now:%{public}" PRIu64 ",vsyncId:%{public}" PRIu64 ", \ + size:%{public}zu, %{public}s", currentRate, param.frameTimestamp, param.vsyncId, layers.size(), + GetSurfaceNameInLayersForTrace(layers).c_str()); + bool isScreenPoweringOff = false; + auto screenManager = CreateOrGetScreenManager(); + if (screenManager) { + isScreenPoweringOff = RSSystemProperties::IsSmallFoldDevice() && + screenManager->IsScreenPoweringOff(output->GetScreenId()); + } + + bool shouldDropFrame = isScreenPoweringOff || IsDropDirtyFrame(layers, output->GetScreenId()); + if (!shouldDropFrame) { + hgmHardwareUtils_.ExecuteSwitchRefreshRate(output, param.rate); + hgmHardwareUtils_.PerformSetActiveMode( + output, param.frameTimestamp, param.constraintRelativeTime); + AddRefreshRateCount(output); + } + + if (RSSystemProperties::IsSuperFoldDisplay() && output->GetScreenId() == 0) { + std::vector reviseLayers = layers; + ChangeLayersForActiveRectOutside(reviseLayers, curScreenId); + output->SetLayerInfo(reviseLayers); + } else { + output->SetLayerInfo(layers); + } + bool doRepaint = output->IsDeviceValid() && !shouldDropFrame; + if (doRepaint) { + hdiBackend_->Repaint(output); + RecordTimestamp(layers); + } + output->ReleaseLayers(releaseFence_); + RSBaseRenderUtil::DecAcquiredBufferCount(); + RSUniRenderThread::Instance().NotifyScreenNodeBufferReleased(); + if (hasGameScene) { + endTimeNs = std::chrono::duration_cast( + std::chrono::steady_clock::now().time_since_epoch()).count(); + FrameReport::GetInstance().SetLastSwapBufferTime(endTimeNs - startTimeNs); + } + + unExecuteTaskNum_--; + RS_LOGD_IF(DEBUG_COMPOSER, "CommitAndReleaseData unExecuteTaskNum_:%{public}d," + " HARDWARE_THREAD_TASK_NUM:%{public}d, %{public}s", + unExecuteTaskNum_.load(), HARDWARE_THREAD_TASK_NUM, surfaceName.c_str()); + if (unExecuteTaskNum_ <= HARDWARE_THREAD_TASK_NUM) { + RSMainThread::Instance()->NotifyHardwareThreadCanExecuteTask(); + } + RSMainThread::Instance()->SetTaskEndWithTime(SystemTime() - lastActualTime_); + lastActualTime_ = param.actualTimestamp; + int64_t endTime = GetCurTimeCount(); + uint64_t frameTime = endTime - startTime; + uint32_t missedFrames = frameTime / REFRESH_PERIOD; + uint16_t frameRate = currentRate; + if (missedFrames >= HARD_JANK_TWO_TIME && + endTime - intervalTimePoints_ > REPORT_LOAD_WARNING_INTERVAL_TIME) { + RS_LOGI("CommitAndReleaseLayers report load event frameTime: %{public}" PRIu64 + " missedFrame: %{public}" PRIu32 " frameRate:%{public}" PRIu16 " %{public}s", + frameTime, missedFrames, frameRate, surfaceName.c_str()); + intervalTimePoints_ = endTime; + RS_TRACE_NAME("RSHardwareThread::CommitAndReleaseLayers HiSysEventWrite in RSHardwareThread"); + RSHiSysEvent::EventWrite(RSEventName::RS_HARDWARE_THREAD_LOAD_WARNING, RSEventType::RS_STATISTIC, + "FRAME_RATE", frameRate, "MISSED_FRAMES", missedFrames, "FRAME_TIME", frameTime); + } EndCheck(timer); } @@ -183,6 +314,31 @@ void RSLayerCompositor::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, Refres delayTime_); } +int32_t RSLayerCompositor::AdaptiveModeStatus(const OutputPtr &output) +{ + if (hdiBackend_ == nullptr) { + RS_LOGE("AdaptiveModeStatus hdiBackend_ is nullptr"); + return SupportASStatus::NOT_SUPPORT; + } + + // 需适配 + auto& hgmCore = OHOS::Rosen::HgmCore::Instance(); + + // if in game adaptive vsync mode and do direct composition,send layer immediately + auto frameRateMgr = hgmCore.GetFrameRateMgr(); + if (frameRateMgr != nullptr) { + int32_t adaptiveStatus = frameRateMgr->AdaptiveStatus(); + RS_LOGD("CommitAndReleaseLayers send layer adaptiveStatus: %{public}u", adaptiveStatus); + if (adaptiveStatus == SupportASStatus::SUPPORT_AS) { + return SupportASStatus::SUPPORT_AS; + } + if (adaptiveStatus == SupportASStatus::GAME_SCENE_SKIP) { + return SupportASStatus::GAME_SCENE_SKIP; + } + } + return SupportASStatus::NOT_SUPPORT; +} + bool RSLayerCompositor::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, const OutputPtr& output, bool hasGameScene) { diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp index 9cb8f58848..7beca82717 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp @@ -40,11 +40,16 @@ void RSLayerCompositorContext::DeleteRenderLayer(NodeId layerId) } -std::unordered_map> RSLayerCompositorContext::GetLayersMap() +std::unordered_map>& RSLayerCompositorContext::GetLayersMap() { return layersMap_; } +std::vector RSLayerCompositorContext::GetLayersVec() +{ + +} + HdiBackend* RSLayerCompositorContext::GetHdiBackend() { return hdiBackend_; diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_agency.cpp similarity index 67% rename from rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_agency.cpp index b6e553b28b..141dd75bcd 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_proxy.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_agency.cpp @@ -12,44 +12,44 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_layer_processor_manager_proxy.h" +#include "rs_render_layer_processor_manager_agency.h" #include "rs_render_layer_processor_manager.h" #include "platform/common/rs_log.h" #include "rs_trace.h" namespace OHOS { namespace Rosen { -RSRenderLayerProcessorManagerProxy::RSRenderLayerProcessorManagerProxy() +RSRenderLayerProcessorManagerAgency::RSRenderLayerProcessorManagerAgency() { rsRenderLayerProcessorManager_ = RSRenderLayerProcessorManager::GetInstance(); } -void RSRenderLayerProcessorManagerProxy::Start() +void RSRenderLayerProcessorManagerAgency::Start() { rsRenderLayerProcessorManager_.Start(); } -void RSRenderLayerProcessorManagerProxy::CreateRenderLayerProcessor(OutputPtr& output) +void RSRenderLayerProcessorManagerAgency::CreateRenderLayerProcessor(OutputPtr& output) { rsRenderLayerProcessorManager_.CreateRenderLayerProcessor(output); } -void RSRenderLayerProcessorManagerProxy::DestroyRenderLayerProcessor(OutputPtr& output) +void RSRenderLayerProcessorManagerAgency::DestroyRenderLayerProcessor(OutputPtr& output) { rsRenderLayerProcessorManager_.DestroyRenderLayerProcessor(output); } -void RSRenderLayerProcessorManagerProxy::PostTask(const std::function& task) +void RSRenderLayerProcessorManagerAgency::PostTask(const std::function& task) { rsRenderLayerProcessorManager_.PostTask(task); } -void RSRenderLayerProcessorManagerProxy::PostSyncTask(const std::function& task) +void RSRenderLayerProcessorManagerAgency::PostSyncTask(const std::function& task) { rsRenderLayerProcessorManager_.PostSyncTask(task); } -void RSRenderLayerProcessorManagerProxy::PostDelayTask(const std::function& task, int64_t delayTime) +void RSRenderLayerProcessorManagerAgency::PostDelayTask(const std::function& task, int64_t delayTime) { rsRenderLayerProcessorManager_.PostDelayTask(task, delayTime); } -- Gitee From 27d4f6fb247ab6e0261ff77ed72c4b059ba50d3f Mon Sep 17 00:00:00 2001 From: m00472246 Date: Wed, 23 Jul 2025 08:52:44 +0000 Subject: [PATCH 04/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- ...layer_compositor.h => rs_layer_composer.h} | 38 ++-- ..._context.h => rs_layer_composer_context.h} | 23 +-- ...processor.h => rs_render_layer_composer.h} | 40 ++-- ...ger.h => rs_render_layer_composer_agent.h} | 35 ++-- ...y.h => rs_render_layer_composer_manager.h} | 41 ++-- .../rs_render_layer_processor_manager.h | 53 ------ .../src/rs_layer_compositor.cpp | 180 +++++++++++++++--- .../src/rs_layer_compositor_context.cpp | 16 +- ...cpp => rs_render_layer_composer_agent.cpp} | 37 +--- ...p => rs_render_layer_composer_manager.cpp} | 66 ++----- .../src/rs_render_layer_processor.cpp | 12 +- 11 files changed, 273 insertions(+), 268 deletions(-) rename rosen/modules/composer/layer_processor/include/{rs_layer_compositor.h => rs_layer_composer.h} (64%) rename rosen/modules/composer/layer_processor/include/{rs_layer_compositor_context.h => rs_layer_composer_context.h} (67%) rename rosen/modules/composer/layer_processor/include/{rs_render_layer_processor.h => rs_render_layer_composer.h} (73%) rename rosen/modules/composer/layer_processor/include/{irs_render_layer_processor_manager.h => rs_render_layer_composer_agent.h} (41%) rename rosen/modules/composer/layer_processor/include/{rs_render_layer_processor_manager_agency.h => rs_render_layer_composer_manager.h} (42%) delete mode 100644 rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h rename rosen/modules/composer/layer_processor/src/{rs_render_layer_processor_manager_agency.cpp => rs_render_layer_composer_agent.cpp} (39%) rename rosen/modules/composer/layer_processor/src/{rs_render_layer_processor_manager.cpp => rs_render_layer_composer_manager.cpp} (48%) diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h b/rosen/modules/composer/layer_processor/include/rs_layer_composer.h similarity index 64% rename from rosen/modules/composer/layer_processor/include/rs_layer_compositor.h rename to rosen/modules/composer/layer_processor/include/rs_layer_composer.h index ccce61b92c..cb732d55c8 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_compositor.h +++ b/rosen/modules/composer/layer_processor/include/rs_layer_composer.h @@ -13,25 +13,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef RS_LAYER_COMPOSITOR_H -#define RS_LAYER_COMPOSITOR_H +#ifndef RS_LAYER_COMPOSER_H +#define RS_LAYER_COMPOSER_H #include -#include "rs_layer_compisitor_context.h" +#include "feature/hyper_graphic_manager/hgm_hardware_utils.h" +#include "pipeline/render_thread/rs_uni_render_engine.h" +#include "rs_layer_compiser_context.h" namespace OHOS::Rosen { using UniFallbackCallback = std::function& surface, const std::vector& layers, uint32_t screenId)>; -using OutputPtr = std::shared_ptr; -class RSLayerCompositor { + +class RSLayerComposer { public: - RSLayerCompositor(OutputPtr output); - ~RSLayerCompositor() = default; + RSLayerComposer(std::shared_ptr& output); + ~RSLayerComposer() = default; // 维护layer - void AddRenderLayer(NodeId layerId); - void UpdateRenderLayer(NodeId layerId); - void DeleteRenderLayer(NodeId layerId); + void AddComposerLayer(NodeId layerId); + void UpdateComposerLayer(NodeId layerId); + void DeleteComposerLayer(NodeId layerId); // 合成 void PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, bool& hasGameScene, @@ -40,22 +42,28 @@ public: void CompleteComposeFrame(); private: - void init(OutputPtr output); + void init(std::shared_ptr& output); void Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId); void OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data); void UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, bool hasGameScene); bool IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, - const OutputPtr& output, bool hasGameScene); + const std::shared_ptr& output, bool hasGameScene); void CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, int64_t currTime); - int32_t AdaptiveModeStatus(const OutputPtr &output); + int32_t AdaptiveModeStatus(const std::shared_ptr& output); void EndCheck(RSTimer timer); + int64_t GetCurTimeCount(); + std::string GetSurfaceNameInLayers(const std::vector& layers); + std::string GetSurfaceNameInLayersForTrace(const std::vector& layers); + void ChangeLayersForActiveRectOutside(std::vector& layers, ScreenId screenId); uint32_t GetUnExecuteTaskNum(); void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); - std::shared_ptr layerCompositorContext_; + std::shared_ptr layerComposerContext_; + std::shared_ptr uniRenderEngine_; + HgmHardwareUtils hgmHardwareUtils_; UniFallbackCallback redrawCb_; int64_t delayTime_ = 0; int64_t lastCommitTime_ = 0; @@ -64,4 +72,4 @@ private: ExceptionCheck exceptionCheck_; } } // namespace OHOS -#endif // RS_LAYER_COMPOSITOR_H \ No newline at end of file +#endif // RS_LAYER_COMPOSER_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h b/rosen/modules/composer/layer_processor/include/rs_layer_composer_context.h similarity index 67% rename from rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h rename to rosen/modules/composer/layer_processor/include/rs_layer_composer_context.h index 4aee6665ed..a970676a7c 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_compositor_context.h +++ b/rosen/modules/composer/layer_processor/include/rs_layer_composer_context.h @@ -14,20 +14,19 @@ * limitations under the License. */ -#ifndef RS_LAYER_COMPOSITOR_CONTEXT_H -#define RS_LAYER_COMPOSITOR_CONTEXT_H +#ifndef RS_LAYER_COMPOSER_CONTEXT_H +#define RS_LAYER_COMPOSER_CONTEXT_H #include "hdi_backend.h" #include "hdi_layer.h" -#include "feature/hyper_graphic_manager/hgm_hardware_utils.h" -#include "pipeline/render_thread/rs_uni_render_engine.h" +#include "hdi_layer_info.h" #include "rs_render_layer.h" namespace OHOS::Rosen { -class RSLayerCompositorContext { +class RSLayerComposerContext { public: - RSLayerCompositorContext(OutputPtr output); - ~RSLayerCompositorContext() = default; + RSLayerComposerContext(std::shared_ptr& output); + ~RSLayerComposerContext() = default; // 维护layer void AddRenderLayer(NodeId layerId); @@ -37,21 +36,17 @@ public: std::unordered_map>& GetLayersMap(); std::vector& GetLayersVec(); HdiBackend* GetHdiBackend(); - OutputPtr GetOutput(); - std::shared_ptr GetHgmHardwareUtils(); + std::shared_ptr GetOutput(); int32_t GetThreadId(); - std::shared_ptr GetUniRenderEngine(); ScreenId GetScreenId(); private: std::unordered_map> layersMap_; std::vector layersVec_; HdiBackend* hdiBackend_ = nullptr; - OutputPtr hdiOutput_; - std::shared_ptr uniRenderEngine_; - std::shared_ptr hgmHardwareUtils_; + std::shared_ptr hdiOutput_; ScreenId screenId_; int32_t threadTid_ = -1; } } // namespace OHOS -#endif // RS_LAYER_COMPOSITOR_CONTEXT_H \ No newline at end of file +#endif // RS_LAYER_COMPOSER_CONTEXT_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_composer.h similarity index 73% rename from rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h rename to rosen/modules/composer/layer_processor/include/rs_render_layer_composer.h index e20b0a8b05..08a2c910c8 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_composer.h @@ -14,22 +14,32 @@ * limitations under the License. */ -#ifndef RS_RENDER_LAYER_PROCESSOR_H -#define RS_RENDER_LAYER_PROCESSOR_H +#ifndef RS_RENDER_LAYER_COMPOSER_H +#define RS_RENDER_LAYER_COMPOSER_H #include #include "event_handler.h" -#include "event_handler.h" -#include "rs_screen_manager.h" -#include "rs_layer_compositor.h" +#include "rs_layer_composer.h" namespace OHOS::Rosen { -class ScheduledTask; -class RSRenderLayerProcessor { +enum ComposerLayerTaskType { + ADD_COMPOSER_LAYER, + UPDATE_COMPOSER_LAYER, + DELETE_COMPOSER_LAYER, +}; +class RSRenderLayerComposer { public: - RSRenderLayerProcessor(OutputPtr output); - ~RSRenderLayerProcessor() = default; - void Start(); + RSRenderLayerComposer(std::shared_ptr& output); + ~RSRenderLayerComposer() = default; + + void PostTask(const std::function& task); + void PostSyncTask(const std::function& task); + void PostDelayTask(const std::function& task, int64_t delayTime); + + void HandleComposerLayer(NodeId layerId, ComposerLayerTaskType eventType); + void ComposerFrame(); + +private: std::future ScheduleTask(Task&& task) { auto [scheduledTask, taskFuture] = Detail::ScheduledTask::Create(std::forward(task)); @@ -38,17 +48,9 @@ public: #endif return std::move(taskFuture); } - void PostTask(const std::function& task); - void PostSyncTask(const std::function& task); - void PostDelayTask(const std::function& task, int64_t delayTime); - void ProcessLayerPostTask(ProcessLayerType layerType, NodeId layerId); - void DoComposeFramePostTask(); - -private: std::shared_ptr runner_ = nullptr; std::shared_ptr handler_ = nullptr; - std::shared_ptr layerCompositor_; - OutputPtr output_; + std::shared_ptr layerComposer_; } } // namespace OHOS #endif // RS_RENDER_LAYER_PROCESSOR_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_agent.h similarity index 41% rename from rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h rename to rosen/modules/composer/layer_processor/include/rs_render_layer_composer_agent.h index 22d88c4051..1eb73fb344 100644 --- a/rosen/modules/composer/layer_processor/include/irs_render_layer_processor_manager.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_agent.h @@ -14,31 +14,22 @@ * limitations under the License. */ -#ifndef IRS_RENDER_LAYER_PROCESSOR_MANAGER_H -#define IRS_RENDER_LAYER_PROCESSOR_MANAGER_H +#ifndef RS_RENDER_LAYER_COMPOSER_AGENT_H +#define RS_RENDER_LAYER_COMPOSER_AGENT_H -#include -#include "hdi_output.h" +#include "rs_render_layer_composer.h" namespace OHOS::Rosen { -enum ProcessSubThreadTaskType { - ADD_COMPOSE_LAYER, - UPDATE_COMPOSE_LAYER, - DELETE_COMPOSE_LAYER, - DO_COMPOSER_FRAME, -}; -class IRSRenderLayerProcessorManager { +class RSRenderLayerComposerAgent { public: - IRSRenderLayerProcessorManager() = default; - virtual ~IRSRenderLayerProcessorManager() = default; - virtual void Start() = 0; - virtual void CreateRenderLayerProcessor(OutputPtr& output) = 0; - virtual void DestroyRenderLayerProcessor(OutputPtr& output) = 0; - virtual void PostTask(const std::function& task) = 0; - virtual void PostSyncTask(const std::function& task) = 0; - virtual void PostDelayTask(const std::function& task, int64_t delayTime) = 0; - template - virtual void DistributeTaskToSubThread(ProcessSubThreadTaskType taskType, T data) = 0; + RSRenderLayerComposerAgent(std::shared_ptr rsRenderLayerComposer); + ~RSRenderLayerComposerAgent() = default; + + void HandleComposerLayer(NodeId layerId, ComposerLayerTaskType taskType); + void ComposerFrame(); + +prvate: + std::shared_ptr rsRenderLayerComposer_; } } // namespace OHOS -#endif // IRS_RENDER_LAYER_PROCESSOR_MANAGER_H +#endif // RS_RENDER_LAYER_COMPOSER_AGENT_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_agency.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_manager.h similarity index 42% rename from rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_agency.h rename to rosen/modules/composer/layer_processor/include/rs_render_layer_composer_manager.h index 2c450ed5ac..a1a60bdbfa 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager_agency.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_manager.h @@ -14,30 +14,29 @@ * limitations under the License. */ -#ifndef RS_RENDER_LAYER_PROCESSOR_MANAGER_AGENCY_H -#define RS_RENDER_LAYER_PROCESSOR_MANAGER_AGENCY_H +#ifndef RS_RENDER_LAYER_COMPOSER_MANAGER_H +#define RS_RENDER_LAYER_COMPOSER_MANAGER_H -#include "irs_render_layer_processor_manager.h" -#include "rs_render_layer_processor.h" +#include "rs_render_layer_composer.h" namespace OHOS::Rosen { -class RSRenderLayerProcessorManagerAgency : public IRSRenderLayerProcessorManager { +class RSRenderLayerComposerManager { public: - RSRenderLayerProcessorManagerAgency(); - ~RSRenderLayerProcessorManagerAgency() = default; - void Start() override; - void CreateRenderLayerProcessor(OutputPtr& output) override; - void DestroyRenderLayerProcessor(OutputPtr& output) override; - void PostTask(const std::function& task) override; - void PostSyncTask(const std::function& task) override; - void PostDelayTask(const std::function& task, int64_t delayTime) override; - template - void DistributeTaskToSubThread(ProcessSubThreadTaskType taskType, T data) override - { - rsRenderLayerProcessorManager_->DistributeTaskToSubThread(taskType, data); - } -prvate: - RSRenderLayerProcessorManager& rsRenderLayerProcessorManager_; + RSRenderLayerComposerManager(std::shared_ptr& handler); + ~RSRenderLayerComposerManager() = default; + void OnScreenConnect(std::shared_ptr& output); + void OnScreenDisconnect(std::shared_ptr& output); + void OnScreenChange(std::shared_ptr& output); + + std::shared_ptr GetRenderLayerComposer(ScreenId screenId); + void PostTask(const std::function& task); + void PostSyncTask(const std::function& task); + void PostDelayTask(const std::function& task, int64_t delayTime); + +private: + std::unordered_map> layerComposerMap_; + std::shared_ptr handler_ = nullptr; + std::mutex mutex_; } } // namespace OHOS -#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_AGENCY_H \ No newline at end of file +#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h b/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h deleted file mode 100644 index f28ac7ab24..0000000000 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_processor_manager.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) 2025-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 RS_RENDER_LAYER_PROCESSOR_MANAGER_H -#define RS_RENDER_LAYER_PROCESSOR_MANAGER_H - -#include "irs_render_layer_processor_manager.h" -#include "rs_render_layer_processor.h" - -namespace OHOS::Rosen { -class RSRenderLayerProcessorManager : public IRSRenderLayerProcessorManager { -public: - static RSRenderLayerProcessorManager& GetInstance(); - - void Start() override; - void CreateRenderLayerProcessor(OutputPtr& output) override; - void DestroyRenderLayerProcessor(OutputPtr& output) override; - void PostTask(const std::function& task) override; - void PostSyncTask(const std::function& task) override; - void PostDelayTask(const std::function& task, int64_t delayTime) override; - template - void DistributeTaskToSubThread(ProcessLayerType taskType, T data) override; - void DumpInfo(DfxString& log); - -private: - RSRenderLayerProcessorManager() = default; - ~RSRenderLayerProcessorManager() = default; - RSRenderLayerProcessorManager(const RSRenderLayerProcessorManager &) = delete; - RSRenderLayerProcessorManager(const RSRenderLayerProcessorManager &&) = delete; - RSRenderLayerProcessorManager &operator = (const RSRenderLayerProcessorManager &) = delete; - RSRenderLayerProcessorManager &operator = (const RSRenderLayerProcessorManager &&) = delete; - - std::unordered_map> layerProcessorMap_; - std::shared_ptr runner_ = nullptr; - std::shared_ptr handler_ = nullptr; - std::mutex mutex_; - int32_t tid_; -} -} // namespace OHOS -#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp index 967ef41549..bfb345bc58 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp @@ -16,8 +16,12 @@ #include #include #include "common/rs_exception_check.h" +#include "common/rs_singleton.h" +#include "gfx/fps_info/rs_surface_fps_manager.h" +#include "gfx/first_frame_notifier/rs_first_frame_notifier.h" #include "hgm_core.h" #include "platform/common/rs_log.h" +#include "platform/common/rs_system_properties.h" #include "rs_trace.h" #include "vsync_sampler.h" @@ -41,12 +45,12 @@ static int64_t SystemTime() return int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec; // 1000000000ns == 1s } -RSLayerCompositor::RSLayerCompositor(OutputPtr output) +RSLayerCompositor::RSLayerCompositor(std::shared_ptr& output) { init(output); } -void RSLayerCompositor::init(OutputPtr output) +void RSLayerCompositor::init(std::shared_ptr& output) { layerCompositorContext_ = std::make_shared(output); redrawCb_ = [this](const sptr& surface, const std::vector& layers, uint32_t screenId) { @@ -60,9 +64,8 @@ void RSLayerCompositor::init(OutputPtr output) RsVulkanContext::GetSingleton().SetIsProtected(false); } #endif - - uniRenderEngine = layerCompositorContext_->GetUniRenderEngine(); - uniRenderEngine->Init(); + uniRenderEngine_ = std::make_shared(); + uniRenderEngine_->Init(); // 需适配 // posttask for multithread safely release surface and image @@ -76,8 +79,7 @@ void RSLayerCompositor::init(OutputPtr output) if (hdiBackend != nullptr) { hdiBackend->RegPrepareComplete(onPrepareCompleteFunc, this); } - auto hgmHardwareUtils = layerCompositorContext_->GetHgmHardwareUtils(); - hgmHardwareUtils->RegisterChangeDssRefreshRateCb(); + hgmHardwareUtils_.RegisterChangeDssRefreshRateCb(); } void RSLayerCompositor::AddRenderLayer(NodeId layerId) @@ -163,26 +165,145 @@ void RSLayerCompositor::EndCheck(RSTimer timer) } } +int64_t RSLayerCompositor::GetCurTimeCount() +{ + auto curTime = std::chrono::system_clock::now().time_since_epoch(); + return std::chrono::duration_cast(curTime).count(); +} + +std::string RSLayerCompositor::GetSurfaceNameInLayers(const std::vector& layers) +{ + std::string surfaceName = "SurfaceName: ["; + bool isFirst = true; + for (const auto& layer : layers) { + if (layer == nullptr || layer->GetSurface() == nullptr) { + continue; + } + if (isFirst) { + surfaceName += layer->GetSurface()->GetName(); + isFirst = false; + continue; + } + surfaceName += ", " + layer->GetSurface()->GetName(); + } + surfaceName += "]"; + return surfaceName; +} + +std::string RSLayerCompositor::GetSurfaceNameInLayersForTrace(const std::vector& layers) +{ + uint32_t count = layers.size(); + uint32_t max = 0; + for (const auto& layer : layers) { + if (layer == nullptr || layer->GetSurface() == nullptr) { + continue; + } + count += layer->GetSurface()->GetName().length(); + if (max < layer->GetZorder()) { + max = layer->GetZorder(); + } + } + bool exceedLimit = count > MAX_TOTAL_SURFACE_NAME_LENGTH; + std::string surfaceName = "Names:"; + for (const auto& layer : layers) { + if (layer == nullptr || layer->GetSurface() == nullptr) { + continue; + } + surfaceName += (exceedLimit ? layer->GetSurface()->GetName().substr(0, MAX_SINGLE_SURFACE_NAME_LENGTH) : + layer->GetSurface()->GetName()) + ","; + surfaceName.append("zorder: "); + surfaceName.append(std::to_string(layer->GetZorder())); + surfaceName.append(","); + if (layer->GetType() == GraphicLayerType::GRAPHIC_LAYER_TYPE_CURSOR && layer->GetZorder() < max) { + RS_LOGE("RSHardcursor is not on the top, hardcursor zorder:%{public}d", layer->GetZorder()); + } + } + + return surfaceName; +} + +void RSLayerCompositor::ChangeLayersForActiveRectOutside(std::vector& layers, ScreenId screenId) +{ +#ifdef ROSEN_EMULATOR + RS_LOGD("emulator device do not need add layer"); + return; +#endif + if (!RSSystemProperties::IsSuperFoldDisplay() || layers.size() == 0) { + return; + } + + // 需适配 + auto screenManager = CreateOrGetScreenManager(); + if (!screenManager) { + return; + } + auto screenInfo = screenManager->QueryScreenInfo(screenId); + const RectI& reviseRect = screenInfo.reviseRect; + if (reviseRect.width_ <= 0 || reviseRect.height_ <= 0) { + return; + } + const RectI& maskRect = screenInfo.maskRect; + if (maskRect.width_ > 0 && maskRect.height_ > 0) { + auto solidColorLayer = HdiLayerInfo::CreateHdiLayerInfo(); + solidColorLayer->SetZorder(INT_MAX - 1); + solidColorLayer->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_NONE); + GraphicIRect dstRect = {maskRect.left_, maskRect.top_, maskRect.width_, maskRect.height_}; + solidColorLayer->SetLayerSize(dstRect); + solidColorLayer->SetIsMaskLayer(true); + solidColorLayer->SetCompositionType(GraphicCompositionType::GRAPHIC_COMPOSITION_SOLID_COLOR); + bool debugFlag = (system::GetParameter("debug.foldscreen.shaft.color", "0") == "1"); + if (debugFlag) { + solidColorLayer->SetLayerColor({0, 255, 0, 255}); + } else { + solidColorLayer->SetLayerColor({0, 0, 0, 255}); + } + layers.emplace_back(solidColorLayer); + } + // 需适配 + using RSRcdManager = RSSingleton; + for (auto& layerInfo : layers) { + auto layerSurface = layerInfo->GetSurface(); + if (layerSurface != nullptr) { + auto rcdlayerInfo = RSRcdManager::GetInstance().GetLayerPair(layerSurface->GetName()); + if (rcdlayerInfo.second != RoundCornerDisplayManager::RCDLayerType::INVALID) { + continue; + } + } + GraphicIRect dstRect = layerInfo->GetLayerSize(); + GraphicIRect tmpRect = dstRect; + int reviseRight = reviseRect.left_ + reviseRect.width_; + int reviseBottom = reviseRect.top_ + reviseRect.height_; + tmpRect.x = std::clamp(dstRect.x, reviseRect.left_, reviseRight); + tmpRect.y = std::clamp(dstRect.y, reviseRect.top_, reviseBottom); + tmpRect.w = std::min(tmpRect.x + dstRect.w, reviseRight) - tmpRect.x; + tmpRect.h = std::min(tmpRect.y + dstRect.h, reviseBottom) - tmpRect.y; + layerInfo->SetLayerSize(tmpRect); + } +} + void RSLayerCompositor::ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId) { std::string threadName = "Hardware_" + std::to_string(layerCompositorContext_->GetScreenId()); RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); - layerCompositorContext_-> + auto layers = layerCompositorContext_->GetLayersVec(); ifdef HIPERF_TRACE_ENABLE RS_LOGW("hiperf_surface_counter3 %{public}" PRIu64 " ", static_cast(layers.size())); #endif int64_t startTime = GetCurTimeCount(); std::string surfaceName = GetSurfaceNameInLayers(layers); RS_LOGD("CommitAndReleaseLayers task execute, %{public}s", surfaceName.c_str()); - if (output == nullptr || hdiBackend_ == nullptr) { + auto output = layerCompositorContext_->GetOutput(); + auto hdiBackend = layerCompositorContext_->GetHdiBackend(); + if (output == nullptr || hdiBackend == nullptr) { RS_LOGI("CommitAndReleaseLayers task return, %{public}s", surfaceName.c_str()); return; } int64_t startTimeNs = 0; int64_t endTimeNs = 0; + // 需适配 RSFirstFrameNotifier::GetInstance().ExecIfFirstFrameCommit(output->GetScreenId()); RS_LOGI_IF(DEBUG_COMPOSER, "CommitAndReleaseData hasGameScene is %{public}d %{public}s", @@ -197,20 +318,21 @@ ifdef HIPERF_TRACE_ENABLE RS_LOGD("CommitLayers rate:%{public}u, now:%{public}" PRIu64 ",vsyncId:%{public}" PRIu64 ", \ size:%{public}zu, %{public}s", currentRate, param.frameTimestamp, param.vsyncId, layers.size(), GetSurfaceNameInLayersForTrace(layers).c_str()); - bool isScreenPoweringOff = false; - auto screenManager = CreateOrGetScreenManager(); - if (screenManager) { - isScreenPoweringOff = RSSystemProperties::IsSmallFoldDevice() && - screenManager->IsScreenPoweringOff(output->GetScreenId()); - } - - bool shouldDropFrame = isScreenPoweringOff || IsDropDirtyFrame(layers, output->GetScreenId()); - if (!shouldDropFrame) { - hgmHardwareUtils_.ExecuteSwitchRefreshRate(output, param.rate); - hgmHardwareUtils_.PerformSetActiveMode( - output, param.frameTimestamp, param.constraintRelativeTime); - AddRefreshRateCount(output); - } + + // bool isScreenPoweringOff = false; + // auto screenManager = CreateOrGetScreenManager(); + // if (screenManager) { + // isScreenPoweringOff = RSSystemProperties::IsSmallFoldDevice() && + // screenManager->IsScreenPoweringOff(output->GetScreenId()); + // } + + // bool shouldDropFrame = isScreenPoweringOff || IsDropDirtyFrame(layers, output->GetScreenId()); + // if (!shouldDropFrame) { + // hgmHardwareUtils_.ExecuteSwitchRefreshRate(output, param.rate); + // hgmHardwareUtils_.PerformSetActiveMode( + // output, param.frameTimestamp, param.constraintRelativeTime); + // AddRefreshRateCount(output); + // } if (RSSystemProperties::IsSuperFoldDisplay() && output->GetScreenId() == 0) { std::vector reviseLayers = layers; @@ -225,6 +347,7 @@ ifdef HIPERF_TRACE_ENABLE RecordTimestamp(layers); } output->ReleaseLayers(releaseFence_); + // 需适配 RSBaseRenderUtil::DecAcquiredBufferCount(); RSUniRenderThread::Instance().NotifyScreenNodeBufferReleased(); if (hasGameScene) { @@ -233,11 +356,12 @@ ifdef HIPERF_TRACE_ENABLE FrameReport::GetInstance().SetLastSwapBufferTime(endTimeNs - startTimeNs); } - unExecuteTaskNum_--; + SubUnExecuteTaskNum(); RS_LOGD_IF(DEBUG_COMPOSER, "CommitAndReleaseData unExecuteTaskNum_:%{public}d," " HARDWARE_THREAD_TASK_NUM:%{public}d, %{public}s", - unExecuteTaskNum_.load(), HARDWARE_THREAD_TASK_NUM, surfaceName.c_str()); - if (unExecuteTaskNum_ <= HARDWARE_THREAD_TASK_NUM) { + GetUnExecuteTaskNum(), HARDWARE_THREAD_TASK_NUM, surfaceName.c_str()); + // 需适配 + if (GetUnExecuteTaskNum() <= HARDWARE_THREAD_TASK_NUM) { RSMainThread::Instance()->NotifyHardwareThreadCanExecuteTask(); } RSMainThread::Instance()->SetTaskEndWithTime(SystemTime() - lastActualTime_); @@ -314,7 +438,7 @@ void RSLayerCompositor::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, Refres delayTime_); } -int32_t RSLayerCompositor::AdaptiveModeStatus(const OutputPtr &output) +int32_t RSLayerCompositor::AdaptiveModeStatus(const std::shared_ptr& output) { if (hdiBackend_ == nullptr) { RS_LOGE("AdaptiveModeStatus hdiBackend_ is nullptr"); @@ -340,7 +464,7 @@ int32_t RSLayerCompositor::AdaptiveModeStatus(const OutputPtr &output) } bool RSLayerCompositor::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, - const OutputPtr& output, bool hasGameScene) + const std::shared_ptr& output, bool hasGameScene) { if (param.isForceRefresh) { RS_LOGD("CommitAndReleaseLayers in Force Refresh"); diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp index 7beca82717..313b93b28f 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp @@ -16,12 +16,10 @@ namespace OHOS { namespace Rosen { -RSLayerCompositorContext::RSLayerCompositorContext(OutputPtr output) : hdiOutput_(output) +RSLayerCompositorContext::RSLayerCompositorContext(std::shared_ptr& output) : hdiOutput_(output) { screenId_ = output->GetScreenId(); hdiBackend_ = HdiBackend::GetInstance(); - uniRenderEngine_ = std::make_shared(); - hgmHardwareUtils_ = std::make_shared(); threadTid_ = gettid(); } @@ -55,26 +53,16 @@ HdiBackend* RSLayerCompositorContext::GetHdiBackend() return hdiBackend_; } -OutputPtr RSLayerCompositorContext::GetOutput() +std::shared_ptr RSLayerCompositorContext::GetOutput() { return hdiOutput_; } -std::shared_ptr RSLayerCompositorContext::GetHgmHardwareUtils() -{ - return hgmHardwareUtils_; -} - int32_t RSLayerCompositorContext::GetThreadId() { return threadTid_; } -std::shared_ptr RSLayerCompositorContext::GetUniRenderEngine() -{ - return uniRenderEngine_; -} - ScreenId RSLayerCompositorContext::GetScreenId() { return screenId_; diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_agency.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_agent.cpp similarity index 39% rename from rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_agency.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_layer_composer_agent.cpp index 141dd75bcd..7941ee00c9 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager_agency.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_agent.cpp @@ -12,46 +12,23 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_layer_processor_manager_agency.h" -#include "rs_render_layer_processor_manager.h" +#include "rs_render_layer_composer_agent.h" #include "platform/common/rs_log.h" #include "rs_trace.h" namespace OHOS { namespace Rosen { -RSRenderLayerProcessorManagerAgency::RSRenderLayerProcessorManagerAgency() -{ - rsRenderLayerProcessorManager_ = RSRenderLayerProcessorManager::GetInstance(); -} - -void RSRenderLayerProcessorManagerAgency::Start() -{ - rsRenderLayerProcessorManager_.Start(); -} - -void RSRenderLayerProcessorManagerAgency::CreateRenderLayerProcessor(OutputPtr& output) -{ - rsRenderLayerProcessorManager_.CreateRenderLayerProcessor(output); -} - -void RSRenderLayerProcessorManagerAgency::DestroyRenderLayerProcessor(OutputPtr& output) -{ - rsRenderLayerProcessorManager_.DestroyRenderLayerProcessor(output); -} - -void RSRenderLayerProcessorManagerAgency::PostTask(const std::function& task) -{ - rsRenderLayerProcessorManager_.PostTask(task); -} +RSRenderLayerComposerAgent::RSRenderLayerComposerAgent(std::shared_ptr rsRenderLayerComposer) : + rsRenderLayerComposer_(rsRenderLayerComposer) {} -void RSRenderLayerProcessorManagerAgency::PostSyncTask(const std::function& task) +void RSRenderLayerComposerAgent::HandleComposerLayer(NodeId layerId, ComposerLayerTaskType taskType) { - rsRenderLayerProcessorManager_.PostSyncTask(task); + rsRenderLayerComposer_->HandleComposerLayer(layerId, taskType); } -void RSRenderLayerProcessorManagerAgency::PostDelayTask(const std::function& task, int64_t delayTime) +void RSRenderLayerComposerAgent::ComposerFrame() { - rsRenderLayerProcessorManager_.PostDelayTask(task, delayTime); + rsRenderLayerComposer_->ComposerFrame(); } } // namespace Rosen } // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_manager.cpp similarity index 48% rename from rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_layer_composer_manager.cpp index 0cd606659c..fd1888d751 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor_manager.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_manager.cpp @@ -12,109 +12,85 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_layer_processor_manager.h" +#include "rs_render_layer_composer_manager.h" #include "platform/common/rs_log.h" #include "rs_trace.h" namespace OHOS { namespace Rosen { -RSRenderLayerProcessorManager& RSRenderLayerProcessorManager::GetInstance() +RSRenderLayerComposerManager::RSRenderLayerComposerManager(std::shared_ptr& handler) : + handler_(handler) { - static RSRenderLayerProcessorManager instance; - return instance; + RS_LOGI("Create RSRenderLayerComposerManager"); } -void RSRenderLayerProcessorManager::Start() -{ - RS_LOGI("Start RSRenderLayerProcessorManager"); - runner_ = AppExecFwk::EventRunner::Create("RSRenderLayerProcessorMainThread"); - handler_ = std::make_shared(runner_); - PostSyncTask([this]() { - // 向屏幕管理注册热插拔函数 - tid_ = gettid(); - }); -} - -void RSRenderLayerProcessorManager::CreateRenderLayerProcessor(OutputPtr& output) +void RSRenderLayerComposerManager::OnScreenConnect(std::shared_ptr& output) { if (output == nullptr) { return; } - RS_LOGI("CreateRenderLayerProcessor screenId: %{public}u", output->GetScreenId()); + RS_LOGI("OnScreenConnect screenId: %{public}u", output->GetScreenId()); std::function task = [this, output = output]() { auto layerProcessor = std::make_shared(output); layerProcessor->Start(); { std::lock_guard lock(mutex_); - layerProcessorMap_.insert(std::pair(output->GetScreenId(), layerProcessor)); + layerComposerMap_.insert(std::pair(output->GetScreenId(), layerProcessor)); } }; PostTask(task); } -void RSRenderLayerProcessorManager::DestroyRenderLayerProcessor(OutputPtr& output) +void RSRenderLayerComposerManager::OnScreenDisconnect(std::shared_ptr& output) { if (output == nullptr) { return; } - RS_LOGI("DestroyRenderLayerProcessor screenId: %{public}u", output->GetScreenId()); + RS_LOGI("OnScreenDisconnect screenId: %{public}u", output->GetScreenId()); std::function task = [this, output = output]() { { std::lock_guard lock(mutex_); - layerProcessorMap_.erase(output->GetScreenId()); + layerComposerMap_.erase(output->GetScreenId()); } }; PostTask(task); } -std::shared_ptr RSRenderLayerProcessorManager::GetRenderLayerProcessor(ScreenId screenId) +void RSRenderLayerComposerManager::OnScreenChange(std::shared_ptr& output) +{ + (void)output; +} + +std::shared_ptr RSRenderLayerComposerManager::GetRenderLayerComposer(ScreenId screenId) { std::lock_guard lock(mutex_); - auto iter = layerProcessorMap_.find(screenId); - if (iter == layerProcessorMap_.end()) { + auto iter = layerComposerMap_.find(screenId); + if (iter == layerComposerMap_.end()) { RS_LOGE("Not find screenId: %{public}u", screenId); return nullptr; } return iter->sencond; } -void RSRenderLayerProcessorManager::PostTask(const std::function& task) +void RSRenderLayerComposerManager::PostTask(const std::function& task) { if (handler_) { handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderLayerProcessorManager::PostSyncTask(const std::function& task) +void RSRenderLayerComposerManager::PostSyncTask(const std::function& task) { if (handler_) { handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderLayerProcessorManager::PostDelayTask(const std::function& task, int64_t delayTime) +void RSRenderLayerComposerManager::PostDelayTask(const std::function& task, int64_t delayTime) { if (handler_) { handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } - -template -void RSRenderLayerProcessorManager::DistributeTaskToSubThread(ProcessLayerType taskType, T data) -{ - switch (taskType) - { - case ADD_COMPOSE_LAYER: - break; - case UPDATE_COMPOSE_LAYER: - break; - case DELETE_COMPOSE_LAYER: - break; - case DO_COMPOSER_FRAME; - break; - default: - break; - } -} } // namespace Rosen } // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp index c87e42bc7a..f2bb1936b0 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp @@ -18,17 +18,15 @@ namespace OHOS { namespace Rosen { -RSRenderLayerProcessor::RSRenderLayerProcessor(OutputPtr output) : output_(output) {} - -void RSRenderLayerProcessor::Start() +RSRenderLayerProcessor::RSRenderLayerProcessor(std::shared_ptr& output) { - RS_LOGI("Start RSRenderLayerProcessor, screenId : %{public}u", output_->GetScreenId()); - std::string threadName = "RSRenderLayerProcessor_" + std::to_string(output_->GetScreenId()); + RS_LOGI("Start RSRenderLayerProcessor, screenId : %{public}u", output->GetScreenId()); + std::string threadName = "RSRenderLayerProcessor_" + std::to_string(output->GetScreenId()); runner_ = AppExecFwk::EventRunner::Create(threadName); handler_ = std::make_shared(runner_); - ScheduleTask([this]() { - layerCompositor_ = std::make_shared(output_); + ScheduleTask([this, output = output]() { + layerCompositor_ = std::make_shared(output); }).wait();; } -- Gitee From f79d12fc58224a011ea351243ee443084398ec38 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Wed, 23 Jul 2025 09:58:31 +0000 Subject: [PATCH 05/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- ..._layer_composer.h => rs_render_composer.h} | 22 +++---- ...context.h => rs_render_composer_context.h} | 20 +++--- ...composer.h => rs_render_composer_thread.h} | 28 ++++----- ...nt.h => rs_render_composer_thread_agent.h} | 23 ++++--- ....h => rs_render_composer_thread_manager.h} | 18 +++--- .../composer/layer_processor/src/adaption.txt | 15 ----- ...ext.cpp => rs_render_composer_context.cpp} | 24 +++---- ...ssor.cpp => rs_render_composer_thread.cpp} | 49 +++++++-------- ...pp => rs_render_composer_thread_agent.cpp} | 24 ++++--- ... => rs_render_composer_thread_manager.cpp} | 28 ++++----- ...ompositor.cpp => rs_render_compositor.cpp} | 62 +++++++++---------- 11 files changed, 152 insertions(+), 161 deletions(-) rename rosen/modules/composer/layer_processor/include/{rs_layer_composer.h => rs_render_composer.h} (86%) rename rosen/modules/composer/layer_processor/include/{rs_layer_composer_context.h => rs_render_composer_context.h} (75%) rename rosen/modules/composer/layer_processor/include/{rs_render_layer_composer.h => rs_render_composer_thread.h} (72%) rename rosen/modules/composer/layer_processor/include/{rs_render_layer_composer_agent.h => rs_render_composer_thread_agent.h} (57%) rename rosen/modules/composer/layer_processor/include/{rs_render_layer_composer_manager.h => rs_render_composer_thread_manager.h} (68%) delete mode 100644 rosen/modules/composer/layer_processor/src/adaption.txt rename rosen/modules/composer/layer_processor/src/{rs_layer_compositor_context.cpp => rs_render_composer_context.cpp} (60%) rename rosen/modules/composer/layer_processor/src/{rs_render_layer_processor.cpp => rs_render_composer_thread.cpp} (52%) rename rosen/modules/composer/layer_processor/src/{rs_render_layer_composer_agent.cpp => rs_render_composer_thread_agent.cpp} (53%) rename rosen/modules/composer/layer_processor/src/{rs_render_layer_composer_manager.cpp => rs_render_composer_thread_manager.cpp} (64%) rename rosen/modules/composer/layer_processor/src/{rs_layer_compositor.cpp => rs_render_compositor.cpp} (89%) diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_composer.h b/rosen/modules/composer/layer_processor/include/rs_render_composer.h similarity index 86% rename from rosen/modules/composer/layer_processor/include/rs_layer_composer.h rename to rosen/modules/composer/layer_processor/include/rs_render_composer.h index cb732d55c8..8b4a44deb8 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_composer.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_composer.h @@ -13,27 +13,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef RS_LAYER_COMPOSER_H -#define RS_LAYER_COMPOSER_H +#ifndef RS_RENDER_COMPOSER_H +#define RS_RENDER_COMPOSER_H #include #include "feature/hyper_graphic_manager/hgm_hardware_utils.h" #include "pipeline/render_thread/rs_uni_render_engine.h" -#include "rs_layer_compiser_context.h" +#include "rs_render_composer_context.h" namespace OHOS::Rosen { using UniFallbackCallback = std::function& surface, const std::vector& layers, uint32_t screenId)>; -class RSLayerComposer { +class RSRenderComposer { public: - RSLayerComposer(std::shared_ptr& output); - ~RSLayerComposer() = default; + RSRenderComposer(std::shared_ptr& output); + ~RSRenderComposer() = default; // 维护layer - void AddComposerLayer(NodeId layerId); - void UpdateComposerLayer(NodeId layerId); - void DeleteComposerLayer(NodeId layerId); + void AddComposerLayer(); + void UpdateComposerLayer(); + void DeleteComposerLayer(); // 合成 void PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, bool& hasGameScene, @@ -61,7 +61,7 @@ private: void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); - std::shared_ptr layerComposerContext_; + std::shared_ptr rsRenderComposerContext_; std::shared_ptr uniRenderEngine_; HgmHardwareUtils hgmHardwareUtils_; UniFallbackCallback redrawCb_; @@ -72,4 +72,4 @@ private: ExceptionCheck exceptionCheck_; } } // namespace OHOS -#endif // RS_LAYER_COMPOSER_H \ No newline at end of file +#endif // RS_RENDER_COMPOSER_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_layer_composer_context.h b/rosen/modules/composer/layer_processor/include/rs_render_composer_context.h similarity index 75% rename from rosen/modules/composer/layer_processor/include/rs_layer_composer_context.h rename to rosen/modules/composer/layer_processor/include/rs_render_composer_context.h index a970676a7c..d2f29edd01 100644 --- a/rosen/modules/composer/layer_processor/include/rs_layer_composer_context.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_composer_context.h @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef RS_LAYER_COMPOSER_CONTEXT_H -#define RS_LAYER_COMPOSER_CONTEXT_H +#ifndef RS_RENDER_COMPOSER_CONTEXT_H +#define RS_RENDER_COMPOSER_CONTEXT_H #include "hdi_backend.h" #include "hdi_layer.h" @@ -23,20 +23,20 @@ #include "rs_render_layer.h" namespace OHOS::Rosen { -class RSLayerComposerContext { +class RSRenderComposerContext { public: - RSLayerComposerContext(std::shared_ptr& output); - ~RSLayerComposerContext() = default; + RSRenderComposerContext(std::shared_ptr& output); + ~RSRenderComposerContext() = default; // 维护layer - void AddRenderLayer(NodeId layerId); - void UpdateRenderLayer(NodeId layerId); - void DeleteRenderLayer(NodeId layerId); + void AddRenderLayer(); + void UpdateRenderLayer(); + void DeleteRenderLayer(); std::unordered_map>& GetLayersMap(); std::vector& GetLayersVec(); HdiBackend* GetHdiBackend(); - std::shared_ptr GetOutput(); + std::shared_ptr& GetOutput(); int32_t GetThreadId(); ScreenId GetScreenId(); @@ -49,4 +49,4 @@ private: int32_t threadTid_ = -1; } } // namespace OHOS -#endif // RS_LAYER_COMPOSER_CONTEXT_H \ No newline at end of file +#endif // RS_RENDER_COMPOSER_CONTEXT_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_composer.h b/rosen/modules/composer/layer_processor/include/rs_render_composer_thread.h similarity index 72% rename from rosen/modules/composer/layer_processor/include/rs_render_layer_composer.h rename to rosen/modules/composer/layer_processor/include/rs_render_composer_thread.h index 08a2c910c8..c84da8a41d 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_composer.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_composer_thread.h @@ -14,31 +14,29 @@ * limitations under the License. */ -#ifndef RS_RENDER_LAYER_COMPOSER_H -#define RS_RENDER_LAYER_COMPOSER_H +#ifndef RS_RENDER_COMPOSER_THREAD_H +#define RS_RENDER_COMPOSER_THREAD_H #include #include "event_handler.h" -#include "rs_layer_composer.h" +#include "rs_render_composer.h" namespace OHOS::Rosen { -enum ComposerLayerTaskType { - ADD_COMPOSER_LAYER, - UPDATE_COMPOSER_LAYER, - DELETE_COMPOSER_LAYER, -}; -class RSRenderLayerComposer { +class RSRendeComposerThread { public: - RSRenderLayerComposer(std::shared_ptr& output); - ~RSRenderLayerComposer() = default; + RSRendeComposerThread(std::shared_ptr& output); + ~RSRendeComposerThread() = default; void PostTask(const std::function& task); void PostSyncTask(const std::function& task); void PostDelayTask(const std::function& task, int64_t delayTime); - void HandleComposerLayer(NodeId layerId, ComposerLayerTaskType eventType); - void ComposerFrame(); + // 维护layer + void AddComposerLayer(); + void UpdateComposerLayer(); + void DeleteComposerLayer(); + void ComposerFrame(); private: std::future ScheduleTask(Task&& task) { @@ -50,7 +48,7 @@ private: } std::shared_ptr runner_ = nullptr; std::shared_ptr handler_ = nullptr; - std::shared_ptr layerComposer_; + std::shared_ptr rsRenderComposer_; } } // namespace OHOS -#endif // RS_RENDER_LAYER_PROCESSOR_H \ No newline at end of file +#endif // RS_RENDER_COMPOSER_THREAD_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_agent.h b/rosen/modules/composer/layer_processor/include/rs_render_composer_thread_agent.h similarity index 57% rename from rosen/modules/composer/layer_processor/include/rs_render_layer_composer_agent.h rename to rosen/modules/composer/layer_processor/include/rs_render_composer_thread_agent.h index 1eb73fb344..bf0c31d9e5 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_agent.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_composer_thread_agent.h @@ -14,22 +14,25 @@ * limitations under the License. */ -#ifndef RS_RENDER_LAYER_COMPOSER_AGENT_H -#define RS_RENDER_LAYER_COMPOSER_AGENT_H +#ifndef RS_RENDER_COMPOSER_THREAD_AGENT_H +#define RS_RENDER_COMPOSER_THREAD_AGENT_H -#include "rs_render_layer_composer.h" +#include "rs_render_composer_thread.h" namespace OHOS::Rosen { -class RSRenderLayerComposerAgent { +class RSRenderComposerThreadAgent { public: - RSRenderLayerComposerAgent(std::shared_ptr rsRenderLayerComposer); - ~RSRenderLayerComposerAgent() = default; + RSRenderComposerThreadAgent(std::shared_ptr rsRenderComposerThread); + ~RSRenderComposerThreadAgent() = default; - void HandleComposerLayer(NodeId layerId, ComposerLayerTaskType taskType); - void ComposerFrame(); + // 维护layer + void AddComposerLayer(); + void UpdateComposerLayer(); + void DeleteComposerLayer(); + void ComposerFrame(); prvate: - std::shared_ptr rsRenderLayerComposer_; + std::shared_ptr rsRenderComposerThread_; } } // namespace OHOS -#endif // RS_RENDER_LAYER_COMPOSER_AGENT_H \ No newline at end of file +#endif // RS_RENDER_COMPOSER_THREAD_AGENT_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_manager.h b/rosen/modules/composer/layer_processor/include/rs_render_composer_thread_manager.h similarity index 68% rename from rosen/modules/composer/layer_processor/include/rs_render_layer_composer_manager.h rename to rosen/modules/composer/layer_processor/include/rs_render_composer_thread_manager.h index a1a60bdbfa..b79320beb4 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_layer_composer_manager.h +++ b/rosen/modules/composer/layer_processor/include/rs_render_composer_thread_manager.h @@ -14,29 +14,29 @@ * limitations under the License. */ -#ifndef RS_RENDER_LAYER_COMPOSER_MANAGER_H -#define RS_RENDER_LAYER_COMPOSER_MANAGER_H +#ifndef RS_RENDER_COMPOSER_THREAD_MANAGER_H +#define RS_RENDER_COMPOSER_THREAD_MANAGER_H -#include "rs_render_layer_composer.h" +#include "rs_render_composer_thread.h" namespace OHOS::Rosen { -class RSRenderLayerComposerManager { +class RSRenderComposerThreadManager { public: - RSRenderLayerComposerManager(std::shared_ptr& handler); - ~RSRenderLayerComposerManager() = default; + RSRenderComposerThreadManager(std::shared_ptr& handler); + ~RSRenderComposerThreadManager() = default; void OnScreenConnect(std::shared_ptr& output); void OnScreenDisconnect(std::shared_ptr& output); void OnScreenChange(std::shared_ptr& output); - std::shared_ptr GetRenderLayerComposer(ScreenId screenId); + std::shared_ptr GetRSRenderComposerThread(ScreenId screenId); void PostTask(const std::function& task); void PostSyncTask(const std::function& task); void PostDelayTask(const std::function& task, int64_t delayTime); private: - std::unordered_map> layerComposerMap_; + std::unordered_map> rsRenderComposerThreadMap_; std::shared_ptr handler_ = nullptr; std::mutex mutex_; } } // namespace OHOS -#endif // RS_RENDER_LAYER_PROCESSOR_MANAGER_H \ No newline at end of file +#endif // RS_RENDER_COMPOSER_THREAD_MANAGER_H \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/adaption.txt b/rosen/modules/composer/layer_processor/src/adaption.txt deleted file mode 100644 index 63323e74d4..0000000000 --- a/rosen/modules/composer/layer_processor/src/adaption.txt +++ /dev/null @@ -1,15 +0,0 @@ -1、vulkancontext单例 -if (RSSystemProperties::IsUseVulkan()) { - RsVulkanContext::GetSingleton().SetIsProtected(false); -} - -2、screenmanager初始化 -auto screenManager = CreateOrGetScreenManager(); -if (screenManager == nullptr || !screenManager->Init()) { - RS_LOGE("RSHardwareThread CreateOrGetScreenManager or init fail."); - return; -} - -3、vulkancontext单例 -// posttask for multithread safely release surface and image -ContextRegisterPostTask(); \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp b/rosen/modules/composer/layer_processor/src/rs_render_composer_context.cpp similarity index 60% rename from rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_composer_context.cpp index 313b93b28f..43750167a3 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor_context.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_composer_context.cpp @@ -12,58 +12,58 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_layer_conpositor_context.h" +#include "rs_render_composer_context.h" namespace OHOS { namespace Rosen { -RSLayerCompositorContext::RSLayerCompositorContext(std::shared_ptr& output) : hdiOutput_(output) +RSRenderComposerContext::RSRenderComposerContext(std::shared_ptr& output) : hdiOutput_(output) { - screenId_ = output->GetScreenId(); hdiBackend_ = HdiBackend::GetInstance(); + screenId_ = output->GetScreenId(); threadTid_ = gettid(); } -void RSLayerCompositorContext::AddRenderLayer(NodeId layerId) +void RSRenderComposerContext::AddRenderLayer() { } -void RSLayerCompositorContext::UpdateRenderLayer(NodeId layerId) +void RSRenderComposerContext::UpdateRenderLayer() { } -void RSLayerCompositorContext::DeleteRenderLayer(NodeId layerId) +void RSRenderComposerContext::DeleteRenderLayer() { } -std::unordered_map>& RSLayerCompositorContext::GetLayersMap() +std::unordered_map>& RSRenderComposerContext::GetLayersMap() { return layersMap_; } -std::vector RSLayerCompositorContext::GetLayersVec() +std::vector RSRenderComposerContext::GetLayersVec() { } -HdiBackend* RSLayerCompositorContext::GetHdiBackend() +HdiBackend* RSRenderComposerContext::GetHdiBackend() { return hdiBackend_; } -std::shared_ptr RSLayerCompositorContext::GetOutput() +std::shared_ptr& RSRenderComposerContext::GetOutput() { return hdiOutput_; } -int32_t RSLayerCompositorContext::GetThreadId() +int32_t RSRenderComposerContext::GetThreadId() { return threadTid_; } -ScreenId RSLayerCompositorContext::GetScreenId() +ScreenId RSRenderComposerContext::GetScreenId() { return screenId_; } diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp b/rosen/modules/composer/layer_processor/src/rs_render_composer_thread.cpp similarity index 52% rename from rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_composer_thread.cpp index f2bb1936b0..25581de255 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_processor.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_composer_thread.cpp @@ -18,71 +18,66 @@ namespace OHOS { namespace Rosen { -RSRenderLayerProcessor::RSRenderLayerProcessor(std::shared_ptr& output) +RSRendeComposerThread::RSRendeComposerThread(std::shared_ptr& output) { - RS_LOGI("Start RSRenderLayerProcessor, screenId : %{public}u", output->GetScreenId()); - std::string threadName = "RSRenderLayerProcessor_" + std::to_string(output->GetScreenId()); + RS_LOGI("Start RSRendeComposerThread, screenId : %{public}u", output->GetScreenId()); + std::string threadName = "RSRendeComposerThread_" + std::to_string(output->GetScreenId()); runner_ = AppExecFwk::EventRunner::Create(threadName); handler_ = std::make_shared(runner_); ScheduleTask([this, output = output]() { - layerCompositor_ = std::make_shared(output); + rsRenderComposer_ = std::make_shared(output); }).wait();; } -void RSRenderLayerProcessor::PostTask(const std::function& task) +void RSRendeComposerThread::PostTask(const std::function& task) { if (handler_) { handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderLayerProcessor::PostSyncTask(const std::function& task) +void RSRendeComposerThread::PostSyncTask(const std::function& task) { if (handler_) { handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderLayerProcessor::PostDelayTask(const std::function& task, int64_t delayTime) +void RSRendeComposerThread::PostDelayTask(const std::function& task, int64_t delayTime) { if (handler_) { handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderLayerProcessor::ProcessLayerPostTask(ProcessLayerType layerType, NodeId layerId) +void RSRendeComposerThread::AddComposerLayer() { - std::function task = [this, layerType = layerType, layerId = layerId]() { - switch (layerType) { - case ADD_COMPOSE_LAYER: - layerCompositor_->AddRenderLayer(layerId); - break; - case UPDATE_COMPOSE_LAYER: - layerCompositor_->UpdateRenderLayer(layerId); - break; - case DELETE_COMPOSE_LAYER: - layerCompositor_->DeleteRenderLayer(layerId); - break; - default: - break; - } - }; - PostTask(task); + +} + +void RSRendeComposerThread::UpdateComposerLayer() +{ + +} + +void RSRendeComposerThread::DeleteComposerLayer() +{ + } -void RSRenderLayerProcessor::DoComposeFramePostTask() +void RSRendeComposerThread::ComposerFrame() { RefreshRateParam param; uint32_t currentRate; bool hasGameScene; ScreenId curScreenId; int64_t delayTime = 0; - layerCompositor_->PrepareComposeFrame(param, currentRate, hasGameScene, curScreenId, delayTime); + rsRenderComposer_->PrepareComposeFrame(param, currentRate, hasGameScene, curScreenId, delayTime); std::function task = [this, param = param, currentRate = currentRate, hasGameScene = hasGameScene, curScreenId = curScreenId]() { - layerCompositor_->ProceseComposeFrame(param, currentRate, hasGameScene, curScreenId); + rsRenderComposer_->ProceseComposeFrame(param, currentRate, hasGameScene, curScreenId); }; PostDelayTask(task, delayTime); } diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_agent.cpp b/rosen/modules/composer/layer_processor/src/rs_render_composer_thread_agent.cpp similarity index 53% rename from rosen/modules/composer/layer_processor/src/rs_render_layer_composer_agent.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_composer_thread_agent.cpp index 7941ee00c9..84817d8343 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_agent.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_composer_thread_agent.cpp @@ -12,23 +12,33 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_layer_composer_agent.h" +#include "rs_render_composer_thread_agent.h" #include "platform/common/rs_log.h" #include "rs_trace.h" namespace OHOS { namespace Rosen { -RSRenderLayerComposerAgent::RSRenderLayerComposerAgent(std::shared_ptr rsRenderLayerComposer) : - rsRenderLayerComposer_(rsRenderLayerComposer) {} +RSRenderComposerThreadAgent::RSRenderComposerThreadAgent(std::shared_ptr rsRenderComposerThread) : + rsRenderComposerThread_(rsRenderComposerThread) {} -void RSRenderLayerComposerAgent::HandleComposerLayer(NodeId layerId, ComposerLayerTaskType taskType) +void RSRenderComposerThreadAgent::AddComposerLayer() { - rsRenderLayerComposer_->HandleComposerLayer(layerId, taskType); + rsRenderComposerThread_->AddComposerLayer(); +} + +void RSRenderComposerThreadAgent::UpdateComposerLayer() +{ + rsRenderComposerThread_->UpdateComposerLayer(); +} + +void RSRenderComposerThreadAgent::DeleteComposerLayer() +{ + rsRenderComposerThread_->DeleteComposerLayer(); } -void RSRenderLayerComposerAgent::ComposerFrame() +void RSRenderComposerThreadAgent::ComposerFrame() { - rsRenderLayerComposer_->ComposerFrame(); + rsRenderComposerThread_->ComposerFrame(); } } // namespace Rosen } // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_manager.cpp b/rosen/modules/composer/layer_processor/src/rs_render_composer_thread_manager.cpp similarity index 64% rename from rosen/modules/composer/layer_processor/src/rs_render_layer_composer_manager.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_composer_thread_manager.cpp index fd1888d751..ecd66d1a11 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_layer_composer_manager.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_composer_thread_manager.cpp @@ -12,19 +12,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_layer_composer_manager.h" +#include "rs_render_composer_thread_manager.h" #include "platform/common/rs_log.h" #include "rs_trace.h" namespace OHOS { namespace Rosen { -RSRenderLayerComposerManager::RSRenderLayerComposerManager(std::shared_ptr& handler) : +RSRenderComposerThreadManager::RSRenderComposerThreadManager(std::shared_ptr& handler) : handler_(handler) { - RS_LOGI("Create RSRenderLayerComposerManager"); + RS_LOGI("Create RSRenderComposerThreadManager"); } -void RSRenderLayerComposerManager::OnScreenConnect(std::shared_ptr& output) +void RSRenderComposerThreadManager::OnScreenConnect(std::shared_ptr& output) { if (output == nullptr) { return; @@ -35,13 +35,13 @@ void RSRenderLayerComposerManager::OnScreenConnect(std::shared_ptr& o layerProcessor->Start(); { std::lock_guard lock(mutex_); - layerComposerMap_.insert(std::pair(output->GetScreenId(), layerProcessor)); + rsRenderComposerThreadMap_.insert(std::pair(output->GetScreenId(), layerProcessor)); } }; PostTask(task); } -void RSRenderLayerComposerManager::OnScreenDisconnect(std::shared_ptr& output) +void RSRenderComposerThreadManager::OnScreenDisconnect(std::shared_ptr& output) { if (output == nullptr) { return; @@ -50,43 +50,43 @@ void RSRenderLayerComposerManager::OnScreenDisconnect(std::shared_ptr std::function task = [this, output = output]() { { std::lock_guard lock(mutex_); - layerComposerMap_.erase(output->GetScreenId()); + rsRenderComposerThreadMap_.erase(output->GetScreenId()); } }; PostTask(task); } -void RSRenderLayerComposerManager::OnScreenChange(std::shared_ptr& output) +void RSRenderComposerThreadManager::OnScreenChange(std::shared_ptr& output) { (void)output; } -std::shared_ptr RSRenderLayerComposerManager::GetRenderLayerComposer(ScreenId screenId) +std::shared_ptr RSRenderComposerThreadManager::GetRSRenderComposerThread(ScreenId screenId) { std::lock_guard lock(mutex_); - auto iter = layerComposerMap_.find(screenId); - if (iter == layerComposerMap_.end()) { + auto iter = rsRenderComposerThreadMap_.find(screenId); + if (iter == rsRenderComposerThreadMap_.end()) { RS_LOGE("Not find screenId: %{public}u", screenId); return nullptr; } return iter->sencond; } -void RSRenderLayerComposerManager::PostTask(const std::function& task) +void RSRenderComposerThreadManager::PostTask(const std::function& task) { if (handler_) { handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderLayerComposerManager::PostSyncTask(const std::function& task) +void RSRenderComposerThreadManager::PostSyncTask(const std::function& task) { if (handler_) { handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderLayerComposerManager::PostDelayTask(const std::function& task, int64_t delayTime) +void RSRenderComposerThreadManager::PostDelayTask(const std::function& task, int64_t delayTime) { if (handler_) { handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); diff --git a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp b/rosen/modules/composer/layer_processor/src/rs_render_compositor.cpp similarity index 89% rename from rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp rename to rosen/modules/composer/layer_processor/src/rs_render_compositor.cpp index bfb345bc58..9b2904e0da 100644 --- a/rosen/modules/composer/layer_processor/src/rs_layer_compositor.cpp +++ b/rosen/modules/composer/layer_processor/src/rs_render_compositor.cpp @@ -12,7 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_layer_compositor.h" +#include "rs_render_compositor.h" #include #include #include "common/rs_exception_check.h" @@ -45,14 +45,14 @@ static int64_t SystemTime() return int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec; // 1000000000ns == 1s } -RSLayerCompositor::RSLayerCompositor(std::shared_ptr& output) +RSRenderComposer::RSRenderComposer(std::shared_ptr& output) { init(output); } -void RSLayerCompositor::init(std::shared_ptr& output) +void RSRenderComposer::init(std::shared_ptr& output) { - layerCompositorContext_ = std::make_shared(output); + rsRenderComposerContext_ = std::make_shared(output); redrawCb_ = [this](const sptr& surface, const std::vector& layers, uint32_t screenId) { return this->Redraw(surface, layers, screenId); }; @@ -75,49 +75,49 @@ void RSLayerCompositor::init(std::shared_ptr& output) OnPrepareComplete(surface, param, data); }; - auto hdiBackend = layerCompositorContext_->GetHdiBackend(); + auto hdiBackend = rsRenderComposerContext_->GetHdiBackend(); if (hdiBackend != nullptr) { hdiBackend->RegPrepareComplete(onPrepareCompleteFunc, this); } hgmHardwareUtils_.RegisterChangeDssRefreshRateCb(); } -void RSLayerCompositor::AddRenderLayer(NodeId layerId) +void RSRenderComposer::AddRenderLayer(NodeId layerId) { } -void RSLayerCompositor::UpdateRenderLayer(NodeId layerId) +void RSRenderComposer::UpdateRenderLayer(NodeId layerId) { } -void RSLayerCompositor::DeleteRenderLayer(NodeId layerId) +void RSRenderComposer::DeleteRenderLayer(NodeId layerId) { } -uint32_t RSLayerCompositor::GetUnExecuteTaskNum() +uint32_t RSRenderComposer::GetUnExecuteTaskNum() { return unExecuteTaskNum_.load(); } -void RSLayerCompositor::IncUnExecuteTaskNum() +void RSRenderComposer::IncUnExecuteTaskNum() { unExecuteTaskNum_.fetch_add(1); } -void RSLayerCompositor::SubUnExecuteTaskNum() +void RSRenderComposer::SubUnExecuteTaskNum() { unExecuteTaskNum_.fetch_sub(1); } -void RSLayerCompositor::PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, +void RSRenderComposer::PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, bool& hasGameScene, ScreenId& curScreenId, int64_t& delayTime) { // 需适配 LayerComposeCollection::GetInstance().UpdateUniformOrOfflineComposeFrameNumberForDFX( - layerCompositorContext_->GetLayersMap()->size()); + rsRenderComposerContext_->GetLayersMap().size()); hgmHardwareUtils_.UpdateRefreshRateParam(); param = hgmHardwareUtils_.GetRefreshRateParam(); @@ -139,7 +139,7 @@ void RSLayerCompositor::PrepareComposeFrame(RefreshRateParam& param, uint32_t& c delayTime = delayTime_; } -void RSLayerCompositor::EndCheck(RSTimer timer) +void RSRenderComposer::EndCheck(RSTimer timer) { exceptionCheck_.pid_ = getpid(); exceptionCheck_.uid_ = getuid(); @@ -165,13 +165,13 @@ void RSLayerCompositor::EndCheck(RSTimer timer) } } -int64_t RSLayerCompositor::GetCurTimeCount() +int64_t RSRenderComposer::GetCurTimeCount() { auto curTime = std::chrono::system_clock::now().time_since_epoch(); return std::chrono::duration_cast(curTime).count(); } -std::string RSLayerCompositor::GetSurfaceNameInLayers(const std::vector& layers) +std::string RSRenderComposer::GetSurfaceNameInLayers(const std::vector& layers) { std::string surfaceName = "SurfaceName: ["; bool isFirst = true; @@ -190,7 +190,7 @@ std::string RSLayerCompositor::GetSurfaceNameInLayers(const std::vector& layers) +std::string RSRenderComposer::GetSurfaceNameInLayersForTrace(const std::vector& layers) { uint32_t count = layers.size(); uint32_t max = 0; @@ -222,7 +222,7 @@ std::string RSLayerCompositor::GetSurfaceNameInLayersForTrace(const std::vector< return surfaceName; } -void RSLayerCompositor::ChangeLayersForActiveRectOutside(std::vector& layers, ScreenId screenId) +void RSRenderComposer::ChangeLayersForActiveRectOutside(std::vector& layers, ScreenId screenId) { #ifdef ROSEN_EMULATOR RS_LOGD("emulator device do not need add layer"); @@ -281,21 +281,21 @@ void RSLayerCompositor::ChangeLayersForActiveRectOutside(std::vectorGetScreenId()); + std::string threadName = "Hardware_" + std::to_string(rsRenderComposerContext_->GetScreenId()); RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); - auto layers = layerCompositorContext_->GetLayersVec(); + auto layers = rsRenderComposerContext_->GetLayersVec(); ifdef HIPERF_TRACE_ENABLE RS_LOGW("hiperf_surface_counter3 %{public}" PRIu64 " ", static_cast(layers.size())); #endif int64_t startTime = GetCurTimeCount(); std::string surfaceName = GetSurfaceNameInLayers(layers); RS_LOGD("CommitAndReleaseLayers task execute, %{public}s", surfaceName.c_str()); - auto output = layerCompositorContext_->GetOutput(); - auto hdiBackend = layerCompositorContext_->GetHdiBackend(); + auto output = rsRenderComposerContext_->GetOutput(); + auto hdiBackend = rsRenderComposerContext_->GetHdiBackend(); if (output == nullptr || hdiBackend == nullptr) { RS_LOGI("CommitAndReleaseLayers task return, %{public}s", surfaceName.c_str()); return; @@ -384,12 +384,12 @@ ifdef HIPERF_TRACE_ENABLE EndCheck(timer); } -void RSLayerCompositor::CompleteComposeFrame() +void RSRenderComposer::CompleteComposeFrame() { } -void RSLayerCompositor::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, +void RSRenderComposer::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, int64_t currTime) { int64_t frameOffset = 0; @@ -438,7 +438,7 @@ void RSLayerCompositor::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, Refres delayTime_); } -int32_t RSLayerCompositor::AdaptiveModeStatus(const std::shared_ptr& output) +int32_t RSRenderComposer::AdaptiveModeStatus(const std::shared_ptr& output) { if (hdiBackend_ == nullptr) { RS_LOGE("AdaptiveModeStatus hdiBackend_ is nullptr"); @@ -463,7 +463,7 @@ int32_t RSLayerCompositor::AdaptiveModeStatus(const std::shared_ptr& return SupportASStatus::NOT_SUPPORT; } -bool RSLayerCompositor::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, +bool RSRenderComposer::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, const std::shared_ptr& output, bool hasGameScene) { if (param.isForceRefresh) { @@ -496,13 +496,13 @@ bool RSLayerCompositor::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRa return true; } -void RSLayerCompositor::UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, +void RSRenderComposer::UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, bool hasGameScene) { delayTime_ = 0; RS_LOGI_IF(DEBUG_COMPOSER, "CommitAndReleaseData hgmCore's LtpoEnabled is %{public}d", hgmCore.GetLtpoEnabled()); int64_t currTime = SystemTime(); - if (IsDelayRequired(hgmCore, param, layerCompositorContext_->GetOutput(), hasGameScene)) { + if (IsDelayRequired(hgmCore, param, rsRenderComposerContext_->GetOutput(), hasGameScene)) { CalculateDelayTime(hgmCore, param, currentRate, currTime); } @@ -525,13 +525,13 @@ void RSLayerCompositor::UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRa lastCommitTime_ = currTime + delayTime_ * NS_MS_UNIT_CONVERSION; } -void RSLayerCompositor::Redraw(const sptr& surface, const std::vector& layers, +void RSRenderComposer::Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId) { } -void RSLayerCompositor::OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data) +void RSRenderComposer::OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data) { // unused data. (void)(data); -- Gitee From 5025ba3a292c86b7d739ecf271373cd17b509f97 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Thu, 24 Jul 2025 01:35:24 +0000 Subject: [PATCH 06/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../base}/include/rs_render_composer.h | 9 +-- .../include/rs_render_composer_context.h | 6 +- .../base}/include/rs_render_composer_thread.h | 2 +- .../include/rs_render_composer_thread_agent.h | 0 .../rs_render_composer_thread_manager.h | 6 +- .../base}/src/rs_render_composer_context.cpp | 0 .../base}/src/rs_render_composer_thread.cpp | 8 +-- .../src/rs_render_composer_thread_agent.cpp | 0 .../src/rs_render_composer_thread_manager.cpp | 0 .../base}/src/rs_render_compositor.cpp | 55 ++++++++++++++----- 10 files changed, 57 insertions(+), 29 deletions(-) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/include/rs_render_composer.h (92%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/include/rs_render_composer_context.h (90%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/include/rs_render_composer_thread.h (96%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/include/rs_render_composer_thread_agent.h (100%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/include/rs_render_composer_thread_manager.h (88%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/src/rs_render_composer_context.cpp (100%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/src/rs_render_composer_thread.cpp (94%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/src/rs_render_composer_thread_agent.cpp (100%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/src/rs_render_composer_thread_manager.cpp (100%) rename rosen/modules/{composer/layer_processor => render_service/core/composer/base}/src/rs_render_compositor.cpp (93%) diff --git a/rosen/modules/composer/layer_processor/include/rs_render_composer.h b/rosen/modules/render_service/core/composer/base/include/rs_render_composer.h similarity index 92% rename from rosen/modules/composer/layer_processor/include/rs_render_composer.h rename to rosen/modules/render_service/core/composer/base/include/rs_render_composer.h index 8b4a44deb8..114eaae3d4 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_composer.h +++ b/rosen/modules/render_service/core/composer/base/include/rs_render_composer.h @@ -27,7 +27,7 @@ using UniFallbackCallback = std::function& surface, con class RSRenderComposer { public: - RSRenderComposer(std::shared_ptr& output); + RSRenderComposer(OutputPtr& output); ~RSRenderComposer() = default; // 维护layer @@ -42,21 +42,22 @@ public: void CompleteComposeFrame(); private: - void init(std::shared_ptr& output); + void init(OutputPtr& output); void Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId); void OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data); void UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, bool hasGameScene); bool IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, - const std::shared_ptr& output, bool hasGameScene); + const OutputPtr& output, bool hasGameScene); void CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, int64_t currTime); - int32_t AdaptiveModeStatus(const std::shared_ptr& output); + int32_t AdaptiveModeStatus(const OutputPtr& output); void EndCheck(RSTimer timer); int64_t GetCurTimeCount(); std::string GetSurfaceNameInLayers(const std::vector& layers); std::string GetSurfaceNameInLayersForTrace(const std::vector& layers); void ChangeLayersForActiveRectOutside(std::vector& layers, ScreenId screenId); + void AddRefreshRateCount(const OutputPtr& output); uint32_t GetUnExecuteTaskNum(); void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); diff --git a/rosen/modules/composer/layer_processor/include/rs_render_composer_context.h b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_context.h similarity index 90% rename from rosen/modules/composer/layer_processor/include/rs_render_composer_context.h rename to rosen/modules/render_service/core/composer/base/include/rs_render_composer_context.h index d2f29edd01..20779b80e1 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_composer_context.h +++ b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_context.h @@ -25,7 +25,7 @@ namespace OHOS::Rosen { class RSRenderComposerContext { public: - RSRenderComposerContext(std::shared_ptr& output); + RSRenderComposerContext(OutputPtr& output); ~RSRenderComposerContext() = default; // 维护layer @@ -36,7 +36,7 @@ public: std::unordered_map>& GetLayersMap(); std::vector& GetLayersVec(); HdiBackend* GetHdiBackend(); - std::shared_ptr& GetOutput(); + OutputPtr& GetOutput(); int32_t GetThreadId(); ScreenId GetScreenId(); @@ -44,7 +44,7 @@ private: std::unordered_map> layersMap_; std::vector layersVec_; HdiBackend* hdiBackend_ = nullptr; - std::shared_ptr hdiOutput_; + OutputPtr hdiOutput_; ScreenId screenId_; int32_t threadTid_ = -1; } diff --git a/rosen/modules/composer/layer_processor/include/rs_render_composer_thread.h b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread.h similarity index 96% rename from rosen/modules/composer/layer_processor/include/rs_render_composer_thread.h rename to rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread.h index c84da8a41d..2a694f8a31 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_composer_thread.h +++ b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread.h @@ -24,7 +24,7 @@ namespace OHOS::Rosen { class RSRendeComposerThread { public: - RSRendeComposerThread(std::shared_ptr& output); + RSRendeComposerThread(OutputPtr& output); ~RSRendeComposerThread() = default; void PostTask(const std::function& task); diff --git a/rosen/modules/composer/layer_processor/include/rs_render_composer_thread_agent.h b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_agent.h similarity index 100% rename from rosen/modules/composer/layer_processor/include/rs_render_composer_thread_agent.h rename to rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_agent.h diff --git a/rosen/modules/composer/layer_processor/include/rs_render_composer_thread_manager.h b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_manager.h similarity index 88% rename from rosen/modules/composer/layer_processor/include/rs_render_composer_thread_manager.h rename to rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_manager.h index b79320beb4..cfa4dfe5a1 100644 --- a/rosen/modules/composer/layer_processor/include/rs_render_composer_thread_manager.h +++ b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_manager.h @@ -24,9 +24,9 @@ class RSRenderComposerThreadManager { public: RSRenderComposerThreadManager(std::shared_ptr& handler); ~RSRenderComposerThreadManager() = default; - void OnScreenConnect(std::shared_ptr& output); - void OnScreenDisconnect(std::shared_ptr& output); - void OnScreenChange(std::shared_ptr& output); + void OnScreenConnect(OutputPtr& output); + void OnScreenDisconnect(OutputPtr& output); + void OnScreenChange(OutputPtr& output); std::shared_ptr GetRSRenderComposerThread(ScreenId screenId); void PostTask(const std::function& task); diff --git a/rosen/modules/composer/layer_processor/src/rs_render_composer_context.cpp b/rosen/modules/render_service/core/composer/base/src/rs_render_composer_context.cpp similarity index 100% rename from rosen/modules/composer/layer_processor/src/rs_render_composer_context.cpp rename to rosen/modules/render_service/core/composer/base/src/rs_render_composer_context.cpp diff --git a/rosen/modules/composer/layer_processor/src/rs_render_composer_thread.cpp b/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread.cpp similarity index 94% rename from rosen/modules/composer/layer_processor/src/rs_render_composer_thread.cpp rename to rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread.cpp index 25581de255..d81ed67af1 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_composer_thread.cpp +++ b/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread.cpp @@ -69,15 +69,15 @@ void RSRendeComposerThread::DeleteComposerLayer() void RSRendeComposerThread::ComposerFrame() { RefreshRateParam param; - uint32_t currentRate; - bool hasGameScene; - ScreenId curScreenId; + uint32_t currentRate = 0; + bool hasGameScene = false; + ScreenId curScreenId = 0; int64_t delayTime = 0; rsRenderComposer_->PrepareComposeFrame(param, currentRate, hasGameScene, curScreenId, delayTime); std::function task = [this, param = param, currentRate = currentRate, hasGameScene = hasGameScene, curScreenId = curScreenId]() { - rsRenderComposer_->ProceseComposeFrame(param, currentRate, hasGameScene, curScreenId); + rsRenderComposer_->ProcessComposeFrame(param, currentRate, hasGameScene, curScreenId); }; PostDelayTask(task, delayTime); } diff --git a/rosen/modules/composer/layer_processor/src/rs_render_composer_thread_agent.cpp b/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_agent.cpp similarity index 100% rename from rosen/modules/composer/layer_processor/src/rs_render_composer_thread_agent.cpp rename to rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_agent.cpp diff --git a/rosen/modules/composer/layer_processor/src/rs_render_composer_thread_manager.cpp b/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_manager.cpp similarity index 100% rename from rosen/modules/composer/layer_processor/src/rs_render_composer_thread_manager.cpp rename to rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_manager.cpp diff --git a/rosen/modules/composer/layer_processor/src/rs_render_compositor.cpp b/rosen/modules/render_service/core/composer/base/src/rs_render_compositor.cpp similarity index 93% rename from rosen/modules/composer/layer_processor/src/rs_render_compositor.cpp rename to rosen/modules/render_service/core/composer/base/src/rs_render_compositor.cpp index 9b2904e0da..6255961b4c 100644 --- a/rosen/modules/composer/layer_processor/src/rs_render_compositor.cpp +++ b/rosen/modules/render_service/core/composer/base/src/rs_render_compositor.cpp @@ -281,6 +281,32 @@ void RSRenderComposer::ChangeLayersForActiveRectOutside(std::vectorGetDefaultScreenId(); + auto& hgmCore = OHOS::Rosen::HgmCore::Instance(); + uint32_t currentRefreshRate = hgmCore.GetScreenCurrentRefreshRate(id); + auto [iter, success] = refreshRateCounts_.try_emplace(currentRefreshRate, 1); + if (!success) { + iter->second++; + } + if (output == nullptr) { + return; + } + RSRealtimeRefreshRateManager::Instance().CountRealtimeFrame(output->GetScreenId()); + auto frameRateMgr = HgmCore::Instance().GetFrameRateMgr(); + if (frameRateMgr == nullptr) { + RS_LOGE("AddRefreshData fail, frameBufferSurfaceOhos_ is nullptr"); + return; + } + frameRateMgr->HandleRsFrame(); +} + void RSRenderComposer::ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId) { @@ -319,20 +345,21 @@ ifdef HIPERF_TRACE_ENABLE size:%{public}zu, %{public}s", currentRate, param.frameTimestamp, param.vsyncId, layers.size(), GetSurfaceNameInLayersForTrace(layers).c_str()); - // bool isScreenPoweringOff = false; - // auto screenManager = CreateOrGetScreenManager(); - // if (screenManager) { - // isScreenPoweringOff = RSSystemProperties::IsSmallFoldDevice() && - // screenManager->IsScreenPoweringOff(output->GetScreenId()); - // } - - // bool shouldDropFrame = isScreenPoweringOff || IsDropDirtyFrame(layers, output->GetScreenId()); - // if (!shouldDropFrame) { - // hgmHardwareUtils_.ExecuteSwitchRefreshRate(output, param.rate); - // hgmHardwareUtils_.PerformSetActiveMode( - // output, param.frameTimestamp, param.constraintRelativeTime); - // AddRefreshRateCount(output); - // } + // 需适配 + bool isScreenPoweringOff = false; + auto screenManager = CreateOrGetScreenManager(); + if (screenManager) { + isScreenPoweringOff = RSSystemProperties::IsSmallFoldDevice() && + screenManager->IsScreenPoweringOff(output->GetScreenId()); + } + + bool shouldDropFrame = isScreenPoweringOff || IsDropDirtyFrame(layers, output->GetScreenId()); + if (!shouldDropFrame) { + hgmHardwareUtils_.ExecuteSwitchRefreshRate(output, param.rate); + hgmHardwareUtils_.PerformSetActiveMode( + output, param.frameTimestamp, param.constraintRelativeTime); + AddRefreshRateCount(output); + } if (RSSystemProperties::IsSuperFoldDisplay() && output->GetScreenId() == 0) { std::vector reviseLayers = layers; -- Gitee From d38bc2c117e0a0ab3c3cb9f11048884960b3dbc3 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Thu, 24 Jul 2025 06:33:51 +0000 Subject: [PATCH 07/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../base/include/rs_render_composer.h | 24 +++- .../base/include/rs_render_composer_agent.h} | 10 +- .../base/include/rs_render_composer_context.h | 11 +- .../include/rs_render_composer_manager.h} | 10 +- .../base/src/rs_render_composer_agent.cpp} | 24 ++-- .../base/src/rs_render_composer_context.cpp | 27 ---- .../base/src/rs_render_composer_manager.cpp} | 31 +++-- .../base/src/rs_render_compositor.cpp | 126 +++++++++++++----- .../base/include/rs_render_composer_thread.h | 54 -------- .../base/src/rs_render_composer_thread.cpp | 85 ------------ 10 files changed, 151 insertions(+), 251 deletions(-) rename rosen/modules/render_service/{core => }/composer/base/include/rs_render_composer.h (79%) rename rosen/modules/render_service/{core/composer/base/include/rs_render_composer_thread_agent.h => composer/base/include/rs_render_composer_agent.h} (76%) rename rosen/modules/render_service/{core => }/composer/base/include/rs_render_composer_context.h (81%) rename rosen/modules/render_service/{core/composer/base/include/rs_render_composer_thread_manager.h => composer/base/include/rs_render_composer_manager.h} (84%) rename rosen/modules/render_service/{core/composer/base/src/rs_render_composer_thread_agent.cpp => composer/base/src/rs_render_composer_agent.cpp} (54%) rename rosen/modules/render_service/{core => }/composer/base/src/rs_render_composer_context.cpp (66%) rename rosen/modules/render_service/{core/composer/base/src/rs_render_composer_thread_manager.cpp => composer/base/src/rs_render_composer_manager.cpp} (60%) rename rosen/modules/render_service/{core => }/composer/base/src/rs_render_compositor.cpp (85%) delete mode 100644 rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread.h delete mode 100644 rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread.cpp diff --git a/rosen/modules/render_service/core/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/base/include/rs_render_composer.h similarity index 79% rename from rosen/modules/render_service/core/composer/base/include/rs_render_composer.h rename to rosen/modules/render_service/composer/base/include/rs_render_composer.h index 114eaae3d4..52ebb1ef22 100644 --- a/rosen/modules/render_service/core/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer.h @@ -17,7 +17,9 @@ #define RS_RENDER_COMPOSER_H #include +#include "event_handler.h" #include "feature/hyper_graphic_manager/hgm_hardware_utils.h" +#include "hdi_backend.h" #include "pipeline/render_thread/rs_uni_render_engine.h" #include "rs_render_composer_context.h" @@ -35,13 +37,18 @@ public: void UpdateComposerLayer(); void DeleteComposerLayer(); + void ComposerFrame(); +private: + void PostTask(const std::function& task); + void PostSyncTask(const std::function& task); + void PostDelayTask(const std::function& task, int64_t delayTime); + // 合成 void PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, bool& hasGameScene, ScreenId& curScreenId, int64_t& delayTime); void ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId); void CompleteComposeFrame(); -private: void init(OutputPtr& output); void Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId); void OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data); @@ -62,6 +69,21 @@ private: void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); + std::future ScheduleTask(Task&& task) + { + auto [scheduledTask, taskFuture] = Detail::ScheduledTask::Create(std::forward(task)); +#ifdef RS_ENABLE_GPU + PostTask([t(std::move(scheduledTask))]() { t->Run(); }); +#endif + return std::move(taskFuture); + } + + std::shared_ptr runner_ = nullptr; + std::shared_ptr handler_ = nullptr; + HdiBackend* hdiBackend_ = nullptr; + OutputPtr hdiOutput_; + int32_t threadTid_ = -1; + ScreenId screenId_; std::shared_ptr rsRenderComposerContext_; std::shared_ptr uniRenderEngine_; HgmHardwareUtils hgmHardwareUtils_; diff --git a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_agent.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h similarity index 76% rename from rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_agent.h rename to rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h index bf0c31d9e5..37d51b29ed 100644 --- a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_agent.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h @@ -17,13 +17,13 @@ #ifndef RS_RENDER_COMPOSER_THREAD_AGENT_H #define RS_RENDER_COMPOSER_THREAD_AGENT_H -#include "rs_render_composer_thread.h" +#include "rs_render_composer.h" namespace OHOS::Rosen { -class RSRenderComposerThreadAgent { +class RSRenderComposerAgent { public: - RSRenderComposerThreadAgent(std::shared_ptr rsRenderComposerThread); - ~RSRenderComposerThreadAgent() = default; + RSRenderComposerAgent(std::shared_ptr rsRenderComposer); + ~RSRenderComposerAgent() = default; // 维护layer void AddComposerLayer(); @@ -32,7 +32,7 @@ public: void ComposerFrame(); prvate: - std::shared_ptr rsRenderComposerThread_; + std::shared_ptr rsRenderComposer_; } } // namespace OHOS #endif // RS_RENDER_COMPOSER_THREAD_AGENT_H \ No newline at end of file diff --git a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_context.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h similarity index 81% rename from rosen/modules/render_service/core/composer/base/include/rs_render_composer_context.h rename to rosen/modules/render_service/composer/base/include/rs_render_composer_context.h index 20779b80e1..130f987a45 100644 --- a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_context.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h @@ -17,7 +17,6 @@ #ifndef RS_RENDER_COMPOSER_CONTEXT_H #define RS_RENDER_COMPOSER_CONTEXT_H -#include "hdi_backend.h" #include "hdi_layer.h" #include "hdi_layer_info.h" #include "rs_render_layer.h" @@ -25,7 +24,7 @@ namespace OHOS::Rosen { class RSRenderComposerContext { public: - RSRenderComposerContext(OutputPtr& output); + RSRenderComposerContext() = default; ~RSRenderComposerContext() = default; // 维护layer @@ -35,18 +34,10 @@ public: std::unordered_map>& GetLayersMap(); std::vector& GetLayersVec(); - HdiBackend* GetHdiBackend(); - OutputPtr& GetOutput(); - int32_t GetThreadId(); - ScreenId GetScreenId(); private: std::unordered_map> layersMap_; std::vector layersVec_; - HdiBackend* hdiBackend_ = nullptr; - OutputPtr hdiOutput_; - ScreenId screenId_; - int32_t threadTid_ = -1; } } // namespace OHOS #endif // RS_RENDER_COMPOSER_CONTEXT_H \ No newline at end of file diff --git a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_manager.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h similarity index 84% rename from rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_manager.h rename to rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h index cfa4dfe5a1..f96ea3427a 100644 --- a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread_manager.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h @@ -14,10 +14,10 @@ * limitations under the License. */ -#ifndef RS_RENDER_COMPOSER_THREAD_MANAGER_H -#define RS_RENDER_COMPOSER_THREAD_MANAGER_H +#ifndef RS_RENDER_COMPOSER_MANAGER_H +#define RS_RENDER_COMPOSER_MANAGER_H -#include "rs_render_composer_thread.h" +#include "rs_render_composer.h" namespace OHOS::Rosen { class RSRenderComposerThreadManager { @@ -28,13 +28,13 @@ public: void OnScreenDisconnect(OutputPtr& output); void OnScreenChange(OutputPtr& output); - std::shared_ptr GetRSRenderComposerThread(ScreenId screenId); + std::shared_ptr GetRSRenderComposer(ScreenId screenId); void PostTask(const std::function& task); void PostSyncTask(const std::function& task); void PostDelayTask(const std::function& task, int64_t delayTime); private: - std::unordered_map> rsRenderComposerThreadMap_; + std::unordered_map> rsRenderComposerMap_; std::shared_ptr handler_ = nullptr; std::mutex mutex_; } diff --git a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_agent.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer_agent.cpp similarity index 54% rename from rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_agent.cpp rename to rosen/modules/render_service/composer/base/src/rs_render_composer_agent.cpp index 84817d8343..83e22f4bc2 100644 --- a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_agent.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer_agent.cpp @@ -12,33 +12,33 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_composer_thread_agent.h" +#include "rs_render_composer_agent.h" #include "platform/common/rs_log.h" #include "rs_trace.h" namespace OHOS { namespace Rosen { -RSRenderComposerThreadAgent::RSRenderComposerThreadAgent(std::shared_ptr rsRenderComposerThread) : - rsRenderComposerThread_(rsRenderComposerThread) {} +RSRenderComposerAgent::RSRenderComposerAgent(std::shared_ptr rsRenderComposer) : + rsRenderComposer_(rsRenderComposer) {} -void RSRenderComposerThreadAgent::AddComposerLayer() +void RSRenderComposerAgent::AddComposerLayer() { - rsRenderComposerThread_->AddComposerLayer(); + rsRenderComposer_->AddComposerLayer(); } - -void RSRenderComposerThreadAgent::UpdateComposerLayer() + +void RSRenderComposerAgent::UpdateComposerLayer() { - rsRenderComposerThread_->UpdateComposerLayer(); + rsRenderComposer_->UpdateComposerLayer(); } -void RSRenderComposerThreadAgent::DeleteComposerLayer() +void RSRenderComposerAgent::DeleteComposerLayer() { - rsRenderComposerThread_->DeleteComposerLayer(); + rsRenderComposer_->DeleteComposerLayer(); } -void RSRenderComposerThreadAgent::ComposerFrame() +void RSRenderComposerAgent::ComposerFrame() { - rsRenderComposerThread_->ComposerFrame(); + rsRenderComposer_->ComposerFrame(); } } // namespace Rosen } // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_context.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp similarity index 66% rename from rosen/modules/render_service/core/composer/base/src/rs_render_composer_context.cpp rename to rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp index 43750167a3..776a0e5170 100644 --- a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_context.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp @@ -16,13 +16,6 @@ namespace OHOS { namespace Rosen { -RSRenderComposerContext::RSRenderComposerContext(std::shared_ptr& output) : hdiOutput_(output) -{ - hdiBackend_ = HdiBackend::GetInstance(); - screenId_ = output->GetScreenId(); - threadTid_ = gettid(); -} - void RSRenderComposerContext::AddRenderLayer() { @@ -47,25 +40,5 @@ std::vector RSRenderComposerContext::GetLayersVec() { } - -HdiBackend* RSRenderComposerContext::GetHdiBackend() -{ - return hdiBackend_; -} - -std::shared_ptr& RSRenderComposerContext::GetOutput() -{ - return hdiOutput_; -} - -int32_t RSRenderComposerContext::GetThreadId() -{ - return threadTid_; -} - -ScreenId RSRenderComposerContext::GetScreenId() -{ - return screenId_; -} } // namespace Rosen } // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_manager.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp similarity index 60% rename from rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_manager.cpp rename to rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp index ecd66d1a11..a5cba1133d 100644 --- a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread_manager.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp @@ -12,36 +12,35 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_composer_thread_manager.h" +#include "rs_render_composer_manager.h" #include "platform/common/rs_log.h" #include "rs_trace.h" namespace OHOS { namespace Rosen { -RSRenderComposerThreadManager::RSRenderComposerThreadManager(std::shared_ptr& handler) : +RSRenderComposerManager::RSRenderComposerManager(std::shared_ptr& handler) : handler_(handler) { - RS_LOGI("Create RSRenderComposerThreadManager"); + RS_LOGI("Create RSRenderComposerManager"); } -void RSRenderComposerThreadManager::OnScreenConnect(std::shared_ptr& output) +void RSRenderComposerManager::OnScreenConnect(OutputPtr& output) { if (output == nullptr) { return; } RS_LOGI("OnScreenConnect screenId: %{public}u", output->GetScreenId()); std::function task = [this, output = output]() { - auto layerProcessor = std::make_shared(output); - layerProcessor->Start(); + auto renderComposer = std::make_shared(output); { std::lock_guard lock(mutex_); - rsRenderComposerThreadMap_.insert(std::pair(output->GetScreenId(), layerProcessor)); + rsRenderComposerMap_.insert(std::pair(output->GetScreenId(), renderComposer)); } }; PostTask(task); } -void RSRenderComposerThreadManager::OnScreenDisconnect(std::shared_ptr& output) +void RSRenderComposerManager::OnScreenDisconnect(OutputPtr& output) { if (output == nullptr) { return; @@ -50,43 +49,43 @@ void RSRenderComposerThreadManager::OnScreenDisconnect(std::shared_ptr task = [this, output = output]() { { std::lock_guard lock(mutex_); - rsRenderComposerThreadMap_.erase(output->GetScreenId()); + rsRenderComposerMap_.erase(output->GetScreenId()); } }; PostTask(task); } -void RSRenderComposerThreadManager::OnScreenChange(std::shared_ptr& output) +void RSRenderComposerManager::OnScreenChange(OutputPtr& output) { (void)output; } -std::shared_ptr RSRenderComposerThreadManager::GetRSRenderComposerThread(ScreenId screenId) +std::shared_ptr RSRenderComposerManager::GetRSRenderComposerThread(ScreenId screenId) { std::lock_guard lock(mutex_); - auto iter = rsRenderComposerThreadMap_.find(screenId); - if (iter == rsRenderComposerThreadMap_.end()) { + auto iter = rsRenderComposerMap_.find(screenId); + if (iter == rsRenderComposerMap_.end()) { RS_LOGE("Not find screenId: %{public}u", screenId); return nullptr; } return iter->sencond; } -void RSRenderComposerThreadManager::PostTask(const std::function& task) +void RSRenderComposerManager::PostTask(const std::function& task) { if (handler_) { handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderComposerThreadManager::PostSyncTask(const std::function& task) +void RSRenderComposerManager::PostSyncTask(const std::function& task) { if (handler_) { handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } -void RSRenderComposerThreadManager::PostDelayTask(const std::function& task, int64_t delayTime) +void RSRenderComposerManager::PostDelayTask(const std::function& task, int64_t delayTime) { if (handler_) { handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); diff --git a/rosen/modules/render_service/core/composer/base/src/rs_render_compositor.cpp b/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp similarity index 85% rename from rosen/modules/render_service/core/composer/base/src/rs_render_compositor.cpp rename to rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp index 6255961b4c..eabbf02fae 100644 --- a/rosen/modules/render_service/core/composer/base/src/rs_render_compositor.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp @@ -45,41 +45,60 @@ static int64_t SystemTime() return int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec; // 1000000000ns == 1s } -RSRenderComposer::RSRenderComposer(std::shared_ptr& output) +RSRenderComposer::RSRenderComposer(OutputPtr& output) { init(output); } -void RSRenderComposer::init(std::shared_ptr& output) +void RSRenderComposer::init(OutputPtr& output) { - rsRenderComposerContext_ = std::make_shared(output); + if (output == nullptr) { + RS_LOGE("RSRenderComposer init output is nullptr"); + return; + } + hdiBackend_ = HdiBackend::GetInstance(); + hdiOutput_ = output; + screenId_ = hdiOutput_->GetScreenId(); + RS_LOGI("Start RSRendeComposerThread, screenId : %{public}u", screenId_); + std::string threadName = "RSRendeComposerThread_" + std::to_string(screenId_); + runner_ = AppExecFwk::EventRunner::Create(threadName); + handler_ = std::make_shared(runner_); + redrawCb_ = [this](const sptr& surface, const std::vector& layers, uint32_t screenId) { return this->Redraw(surface, layers, screenId); }; + rsRenderComposerContext_ = std::make_shared(); - // 需适配 + if (handler_) { + ScheduleTask( + [this]() { + // 需适配 #if defined (RS_ENABLE_VK) - // Change vk interface type from UNIRENDER into UNPROTECTED_REDRAW, this is necessary for hardware init. - if (RSSystemProperties::IsUseVulkan()) { - RsVulkanContext::GetSingleton().SetIsProtected(false); - } + // Change vk interface type from UNIRENDER into UNPROTECTED_REDRAW, this is necessary for hardware init. + if (RSSystemProperties::IsUseVulkan()) { + RsVulkanContext::GetSingleton().SetIsProtected(false); + } #endif - uniRenderEngine_ = std::make_shared(); - uniRenderEngine_->Init(); - - // 需适配 - // posttask for multithread safely release surface and image - ContextRegisterPostTask(); +#ifdef RES_SCHED_ENABLE + // 需适配 + SubScribeSystemAbility(); +#endif + uniRenderEngine_ = std::make_shared(); + uniRenderEngine_->Init(); + // 需适配 + // posttask for multithread safely release surface and image + ContextRegisterPostTask(); + threadTid_ = gettid(); + }).wait(); + } auto onPrepareCompleteFunc = [this](auto& surface, const auto& param, void* data) { OnPrepareComplete(surface, param, data); }; - auto hdiBackend = rsRenderComposerContext_->GetHdiBackend(); - if (hdiBackend != nullptr) { - hdiBackend->RegPrepareComplete(onPrepareCompleteFunc, this); + if (hdiBackend_ != nullptr) { + hdiBackend_->RegPrepareComplete(onPrepareCompleteFunc, this); } - hgmHardwareUtils_.RegisterChangeDssRefreshRateCb(); } void RSRenderComposer::AddRenderLayer(NodeId layerId) @@ -298,7 +317,7 @@ void RSRenderComposer::AddRefreshRateCount(const OutputPtr& output) if (output == nullptr) { return; } - RSRealtimeRefreshRateManager::Instance().CountRealtimeFrame(output->GetScreenId()); + RSRealtimeRefreshRateManager::Instance().CountRealtimeFrame(screenId_); auto frameRateMgr = HgmCore::Instance().GetFrameRateMgr(); if (frameRateMgr == nullptr) { RS_LOGE("AddRefreshData fail, frameBufferSurfaceOhos_ is nullptr"); @@ -310,7 +329,7 @@ void RSRenderComposer::AddRefreshRateCount(const OutputPtr& output) void RSRenderComposer::ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId) { - std::string threadName = "Hardware_" + std::to_string(rsRenderComposerContext_->GetScreenId()); + std::string threadName = "Hardware_" + std::to_string(screenId_); RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); auto layers = rsRenderComposerContext_->GetLayersVec(); @@ -320,9 +339,7 @@ ifdef HIPERF_TRACE_ENABLE int64_t startTime = GetCurTimeCount(); std::string surfaceName = GetSurfaceNameInLayers(layers); RS_LOGD("CommitAndReleaseLayers task execute, %{public}s", surfaceName.c_str()); - auto output = rsRenderComposerContext_->GetOutput(); - auto hdiBackend = rsRenderComposerContext_->GetHdiBackend(); - if (output == nullptr || hdiBackend == nullptr) { + if (hdiOutput_ == nullptr || hdiBackend_ == nullptr) { RS_LOGI("CommitAndReleaseLayers task return, %{public}s", surfaceName.c_str()); return; } @@ -330,7 +347,7 @@ ifdef HIPERF_TRACE_ENABLE int64_t endTimeNs = 0; // 需适配 - RSFirstFrameNotifier::GetInstance().ExecIfFirstFrameCommit(output->GetScreenId()); + RSFirstFrameNotifier::GetInstance().ExecIfFirstFrameCommit(screenId_); RS_LOGI_IF(DEBUG_COMPOSER, "CommitAndReleaseData hasGameScene is %{public}d %{public}s", hasGameScene, surfaceName.c_str()); @@ -350,25 +367,25 @@ ifdef HIPERF_TRACE_ENABLE auto screenManager = CreateOrGetScreenManager(); if (screenManager) { isScreenPoweringOff = RSSystemProperties::IsSmallFoldDevice() && - screenManager->IsScreenPoweringOff(output->GetScreenId()); + screenManager->IsScreenPoweringOff(screenId_); } - bool shouldDropFrame = isScreenPoweringOff || IsDropDirtyFrame(layers, output->GetScreenId()); + bool shouldDropFrame = isScreenPoweringOff || IsDropDirtyFrame(layers, screenId_); if (!shouldDropFrame) { - hgmHardwareUtils_.ExecuteSwitchRefreshRate(output, param.rate); + hgmHardwareUtils_.ExecuteSwitchRefreshRate(hdiOutput_, param.rate); hgmHardwareUtils_.PerformSetActiveMode( - output, param.frameTimestamp, param.constraintRelativeTime); - AddRefreshRateCount(output); + hdiOutput_, param.frameTimestamp, param.constraintRelativeTime); + AddRefreshRateCount(hdiOutput_); } - if (RSSystemProperties::IsSuperFoldDisplay() && output->GetScreenId() == 0) { + if (RSSystemProperties::IsSuperFoldDisplay() && screenId_ == 0) { std::vector reviseLayers = layers; ChangeLayersForActiveRectOutside(reviseLayers, curScreenId); - output->SetLayerInfo(reviseLayers); + hdiOutput_->SetLayerInfo(reviseLayers); } else { - output->SetLayerInfo(layers); + hdiOutput_->SetLayerInfo(layers); } - bool doRepaint = output->IsDeviceValid() && !shouldDropFrame; + bool doRepaint = hdiOutput_->IsDeviceValid() && !shouldDropFrame; if (doRepaint) { hdiBackend_->Repaint(output); RecordTimestamp(layers); @@ -416,6 +433,22 @@ void RSRenderComposer::CompleteComposeFrame() } +void RSRenderComposer::ComposerFrame() +{ + RefreshRateParam param; + uint32_t currentRate = 0; + bool hasGameScene = false; + ScreenId curScreenId = 0; + int64_t delayTime = 0; + PrepareComposeFrame(param, currentRate, hasGameScene, curScreenId, delayTime); + + std::function task = [this, param = param, currentRate = currentRate, + hasGameScene = hasGameScene, curScreenId = curScreenId]() { + ProcessComposeFrame(param, currentRate, hasGameScene, curScreenId); + }; + PostDelayTask(task, delayTime); +} + void RSRenderComposer::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, uint32_t currentRate, int64_t currTime) { @@ -465,7 +498,7 @@ void RSRenderComposer::CalculateDelayTime(OHOS::Rosen::HgmCore& hgmCore, Refresh delayTime_); } -int32_t RSRenderComposer::AdaptiveModeStatus(const std::shared_ptr& output) +int32_t RSRenderComposer::AdaptiveModeStatus(const OutputPtr& output) { if (hdiBackend_ == nullptr) { RS_LOGE("AdaptiveModeStatus hdiBackend_ is nullptr"); @@ -491,7 +524,7 @@ int32_t RSRenderComposer::AdaptiveModeStatus(const std::shared_ptr& o } bool RSRenderComposer::IsDelayRequired(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, - const std::shared_ptr& output, bool hasGameScene) + const OutputPtr& output, bool hasGameScene) { if (param.isForceRefresh) { RS_LOGD("CommitAndReleaseLayers in Force Refresh"); @@ -529,7 +562,7 @@ void RSRenderComposer::UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRat delayTime_ = 0; RS_LOGI_IF(DEBUG_COMPOSER, "CommitAndReleaseData hgmCore's LtpoEnabled is %{public}d", hgmCore.GetLtpoEnabled()); int64_t currTime = SystemTime(); - if (IsDelayRequired(hgmCore, param, rsRenderComposerContext_->GetOutput(), hasGameScene)) { + if (IsDelayRequired(hgmCore, param, hdiOutput_, hasGameScene)) { CalculateDelayTime(hgmCore, param, currentRate, currTime); } @@ -571,5 +604,26 @@ void RSRenderComposer::OnPrepareComplete(sptr& surface, const PrepareCo redrawCb_(surface, param.layers, param.screenId); } } + +void RSRenderComposer::PostTask(const std::function& task) +{ + if (handler_) { + handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} + +void RSRenderComposer::PostSyncTask(const std::function& task) +{ + if (handler_) { + handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} + +void RSRenderComposer::PostDelayTask(const std::function& task, int64_t delayTime) +{ + if (handler_) { + handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); + } +} } // namespace Rosen } // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread.h b/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread.h deleted file mode 100644 index 2a694f8a31..0000000000 --- a/rosen/modules/render_service/core/composer/base/include/rs_render_composer_thread.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2025-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 RS_RENDER_COMPOSER_THREAD_H -#define RS_RENDER_COMPOSER_THREAD_H - -#include -#include "event_handler.h" -#include "rs_render_composer.h" - -namespace OHOS::Rosen { -class RSRendeComposerThread { -public: - RSRendeComposerThread(OutputPtr& output); - ~RSRendeComposerThread() = default; - - void PostTask(const std::function& task); - void PostSyncTask(const std::function& task); - void PostDelayTask(const std::function& task, int64_t delayTime); - - // 维护layer - void AddComposerLayer(); - void UpdateComposerLayer(); - void DeleteComposerLayer(); - - void ComposerFrame(); -private: - std::future ScheduleTask(Task&& task) - { - auto [scheduledTask, taskFuture] = Detail::ScheduledTask::Create(std::forward(task)); -#ifdef RS_ENABLE_GPU - PostTask([t(std::move(scheduledTask))]() { t->Run(); }); -#endif - return std::move(taskFuture); - } - std::shared_ptr runner_ = nullptr; - std::shared_ptr handler_ = nullptr; - std::shared_ptr rsRenderComposer_; -} -} // namespace OHOS -#endif // RS_RENDER_COMPOSER_THREAD_H \ No newline at end of file diff --git a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread.cpp b/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread.cpp deleted file mode 100644 index d81ed67af1..0000000000 --- a/rosen/modules/render_service/core/composer/base/src/rs_render_composer_thread.cpp +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (c) 2025-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 "rs_render_layer_processor.h" -#include "platform/common/rs_log.h" -#include "rs_trace.h" - -namespace OHOS { -namespace Rosen { -RSRendeComposerThread::RSRendeComposerThread(std::shared_ptr& output) -{ - RS_LOGI("Start RSRendeComposerThread, screenId : %{public}u", output->GetScreenId()); - std::string threadName = "RSRendeComposerThread_" + std::to_string(output->GetScreenId()); - runner_ = AppExecFwk::EventRunner::Create(threadName); - handler_ = std::make_shared(runner_); - - ScheduleTask([this, output = output]() { - rsRenderComposer_ = std::make_shared(output); - }).wait();; -} - -void RSRendeComposerThread::PostTask(const std::function& task) -{ - if (handler_) { - handler_->PostTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); - } -} - -void RSRendeComposerThread::PostSyncTask(const std::function& task) -{ - if (handler_) { - handler_->PostSyncTask(task, AppExecFwk::EventQueue::Priority::IMMEDIATE); - } -} - -void RSRendeComposerThread::PostDelayTask(const std::function& task, int64_t delayTime) -{ - if (handler_) { - handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); - } -} - -void RSRendeComposerThread::AddComposerLayer() -{ - -} - -void RSRendeComposerThread::UpdateComposerLayer() -{ - -} - -void RSRendeComposerThread::DeleteComposerLayer() -{ - -} - -void RSRendeComposerThread::ComposerFrame() -{ - RefreshRateParam param; - uint32_t currentRate = 0; - bool hasGameScene = false; - ScreenId curScreenId = 0; - int64_t delayTime = 0; - rsRenderComposer_->PrepareComposeFrame(param, currentRate, hasGameScene, curScreenId, delayTime); - - std::function task = [this, param = param, currentRate = currentRate, - hasGameScene = hasGameScene, curScreenId = curScreenId]() { - rsRenderComposer_->ProcessComposeFrame(param, currentRate, hasGameScene, curScreenId); - }; - PostDelayTask(task, delayTime); -} -} // namespace Rosen -} // namespace OHOSl \ No newline at end of file -- Gitee From 8784d89b4efde8636f838f32d96a549dfcf99d2a Mon Sep 17 00:00:00 2001 From: m00472246 Date: Thu, 24 Jul 2025 09:32:53 +0000 Subject: [PATCH 08/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- rosen/modules/render_service/BUILD.gn | 7 + .../base/include/rs_render_composer.h | 14 +- .../base/src/rs_render_compositor.cpp | 297 ++++++++++++++++++ 3 files changed, 317 insertions(+), 1 deletion(-) diff --git a/rosen/modules/render_service/BUILD.gn b/rosen/modules/render_service/BUILD.gn index 65c98d9fb2..8941ecfa82 100644 --- a/rosen/modules/render_service/BUILD.gn +++ b/rosen/modules/render_service/BUILD.gn @@ -281,6 +281,13 @@ ohos_shared_library("librender_service") { "core/pipeline/render_thread/rs_uni_render_util.cpp", "core/pipeline/render_thread/rs_uni_render_virtual_processor.cpp", ] + #composer + sources += [ + "composer/base/src/rs_render_composer_agnet.cpp", + "composer/base/src/rs_render_composer_context.cpp", + "composer/base/src/rs_render_composer_manager.cpp", + "composer/base/src/rs_render_composer.cpp", + ] } if (graphic_2d_feature_enable_rdo) { diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/base/include/rs_render_composer.h index 52ebb1ef22..fa6ef0a612 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer.h @@ -20,13 +20,14 @@ #include "event_handler.h" #include "feature/hyper_graphic_manager/hgm_hardware_utils.h" #include "hdi_backend.h" +#include "pipeline/main_thread/rs_main_thread.h" #include "pipeline/render_thread/rs_uni_render_engine.h" #include "rs_render_composer_context.h" namespace OHOS::Rosen { using UniFallbackCallback = std::function& surface, const std::vector& layers, uint32_t screenId)>; - +class ScheduledTask; class RSRenderComposer { public: RSRenderComposer(OutputPtr& output); @@ -38,6 +39,7 @@ public: void DeleteComposerLayer(); void ComposerFrame(); + int32_t GetHardwareThreadTid() const; private: void PostTask(const std::function& task); void PostSyncTask(const std::function& task); @@ -65,6 +67,16 @@ private: std::string GetSurfaceNameInLayersForTrace(const std::vector& layers); void ChangeLayersForActiveRectOutside(std::vector& layers, ScreenId screenId); void AddRefreshRateCount(const OutputPtr& output); + void RecordTimestamp(const std::vector& layers); + bool IsDropDirtyFrame(const std::vector& layerInfos, uint32_t screenId); +#ifdef USE_VIDEO_PROCESSING_ENGINE + static GraphicColorGamut ComputeTargetColorGamut(const std::vector& layers); + static GraphicPixelFormat ComputeTargetPixelFormat(const std::vector& layers); + static bool ConvertColorGamutToSpaceType(const GraphicColorGamut& colorGamut, + HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType& colorSpaceInfo); +#endif + void RedrawScreenRCD(RSPaintFilterCanvas& canvas, const std::vector& layers); + uint32_t GetUnExecuteTaskNum(); void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); diff --git a/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp b/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp index eabbf02fae..124896188f 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp @@ -116,6 +116,11 @@ void RSRenderComposer::DeleteRenderLayer(NodeId layerId) } +int32_t RSRenderComposer::GetHardwareThreadTid() const +{ + return threadTid_; +} + uint32_t RSRenderComposer::GetUnExecuteTaskNum() { return unExecuteTaskNum_.load(); @@ -302,6 +307,7 @@ void RSRenderComposer::ChangeLayersForActiveRectOutside(std::vectorHandleRsFrame(); } +void RSHardwareThread::RecordTimestamp(const std::vector& layers) +{ + uint64_t currentTime = static_cast( + std::chrono::duration_cast( + std::chrono::steady_clock::now().time_since_epoch()).count()); + for (auto& layer : layers) { + if (layer == nullptr) { + continue; + } + uint64_t id = layer->GetNodeId(); + auto& surfaceFpsManager = RSSurfaceFpsManager::GetInstance(); + if (layer->GetBuffer() == nullptr) { + continue; + } + surfaceFpsManager.RecordPresentTime(id, currentTime, layer->GetBuffer()->GetSeqNum()); + } +} + +bool RSRenderComposer::IsDropDirtyFrame(const std::vector& layerInfos, uint32_t screenId) +{ +#ifdef ROSEN_EMULATOR + RS_LOGD("emulator device do not need drop dirty frame"); + return false; +#endif + if (!RSSystemProperties::IsSuperFoldDisplay()) { + return false; + } + // 需适配 + auto screenManager = CreateOrGetScreenManager(); + if (screenManager == nullptr) { + RS_LOGW("%{public}s: screenManager is null", __func__); + return false; + } + + auto rect = screenManager->QueryScreenInfo(screenId).activeRect; + if (rect.IsEmpty()) { + RS_LOGW("%{public}s: activeRect is empty", __func__); + return false; + } + GraphicIRect activeRect = {rect.left_, rect.top_, rect.width_, rect.height_}; + if (layerInfos.empty()) { + RS_LOGI("%{public}s: layerInfos is empty", __func__); + return false; + } + for (const auto& info : layerInfos) { + if (info == nullptr) { + continue; + } + auto layerSize = info->GetLayerSize(); + if (info->GetUniRenderFlag() && !(activeRect == layerSize)) { + RS_LOGI("%{publkic}s: Drop dirty frame cause activeRect:[%{public}d, %{public}d, %{public}d, %{public}d]" \ + "layerSize:[%{public}d, %{public}d, %{public}d, %{public}d]", __func__, activeRect.x, activeRect.y, + activeRect.w, activeRect.h, layerSize.x, layerSize.y, layerSize.w, layerSize.h); + return true; + } + } + return false; +} + void RSRenderComposer::ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId) { @@ -585,10 +650,242 @@ void RSRenderComposer::UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRat lastCommitTime_ = currTime + delayTime_ * NS_MS_UNIT_CONVERSION; } +#ifdef USE_VIDEO_PROCESSING_ENGINE +GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const std::vector& layers) +{ + using namespace HDI::Display::Graphic::Common::V1_0; + GraphicColorGamut colorGamut = GRAPHIC_COLOR_GAMUT_SRGB; + for (auto& layer : layers) { + if (layer == nullptr) { + RS_LOGE("ComputeTargetColorGamut layer is nullptr"); + continue; + } + auto buffer = layer->GetBuffer(); + if (buffer == nullptr) { + RS_LOGW("ComputeTargetColorGamut The buffer of layer is nullptr"); + continue; + } + + CM_ColorSpaceInfo colorSpaceInfo; + if (MetadataHelper::GetColorSpaceInfo(buffer, colorSpaceInfo) != GSERROR_OK) { + RS_LOGD("ComputeTargetColorGamut Get color space failed"); + continue; + } + + if (colorSpaceInfo.primaries != COLORPRIMARIES_SRGB) { + RS_LOGD("ComputeTargetColorData fail, primaries is %{public}d", + colorSpaceInfo.primaries); + colorGamut = GRAPHIC_COLOR_GAMUT_DISPLAY_P3; + break; + } + } + + return colorGamut; +} + +GraphicPixelFormat RSHardwareThread::ComputeTargetPixelFormat(const std::vector& layers) +{ + using namespace HDI::Display::Graphic::Common::V1_0; + GraphicPixelFormat pixelFormat = GRAPHIC_PIXEL_FMT_RGBA_8888; + for (auto& layer : layers) { + if (layer == nullptr) { + continue; + } + auto buffer = layer->GetBuffer(); + if (buffer == nullptr) { + RS_LOGW("ComputeTargetPixelFormat The buffer of layer is nullptr"); + continue; + } + + auto bufferPixelFormat = buffer->GetFormat(); + if (bufferPixelFormat == GRAPHIC_PIXEL_FMT_RGBA_1010108) { + pixelFormat = GRAPHIC_PIXEL_FMT_RGBA_1010102; + if (RSHdrUtil::GetRGBA1010108Enabled()) { + pixelFormat = GRAPHIC_PIXEL_FMT_RGBA_1010108; + RS_LOGD("ComputeTargetPixelFormat pixelformat is set to GRAPHIC_PIXEL_FMT_RGBA_1010108"); + } + break; + } + if (bufferPixelFormat == GRAPHIC_PIXEL_FMT_RGBA_1010102 || + bufferPixelFormat == GRAPHIC_PIXEL_FMT_YCBCR_P010 || + bufferPixelFormat == GRAPHIC_PIXEL_FMT_YCRCB_P010) { + pixelFormat = GRAPHIC_PIXEL_FMT_RGBA_1010102; + RS_LOGD("ComputeTargetPixelFormat pixelformat is set to 1010102 for 10bit buffer"); + } + } + + return pixelFormat; +} + +bool RSHardwareThread::ConvertColorGamutToSpaceType(const GraphicColorGamut& colorGamut, + HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType& colorSpaceType) +{ + using namespace HDI::Display::Graphic::Common::V1_0; + static const std::map RS_TO_COMMON_COLOR_SPACE_TYPE_MAP { + {GRAPHIC_COLOR_GAMUT_STANDARD_BT601, CM_BT601_EBU_FULL}, + {GRAPHIC_COLOR_GAMUT_STANDARD_BT709, CM_BT709_FULL}, + {GRAPHIC_COLOR_GAMUT_SRGB, CM_SRGB_FULL}, + {GRAPHIC_COLOR_GAMUT_ADOBE_RGB, CM_ADOBERGB_FULL}, + {GRAPHIC_COLOR_GAMUT_DISPLAY_P3, CM_P3_FULL}, + {GRAPHIC_COLOR_GAMUT_BT2020, CM_DISPLAY_BT2020_SRGB}, + {GRAPHIC_COLOR_GAMUT_BT2100_PQ, CM_BT2020_PQ_FULL}, + {GRAPHIC_COLOR_GAMUT_BT2100_HLG, CM_BT2020_HLG_FULL}, + {GRAPHIC_COLOR_GAMUT_DISPLAY_BT2020, CM_DISPLAY_BT2020_SRGB}, + }; + + if (RS_TO_COMMON_COLOR_SPACE_TYPE_MAP.find(colorGamut) == RS_TO_COMMON_COLOR_SPACE_TYPE_MAP.end()) { + return false; + } + + colorSpaceType = RS_TO_COMMON_COLOR_SPACE_TYPE_MAP.at(colorGamut); + return true; +} +#endif + +void RSHardwareThread::RedrawScreenRCD(RSPaintFilterCanvas& canvas, const std::vector& layers) +{ + RS_TRACE_NAME("RSHardwareThread::RedrawScreenRCD， threadId: " + std::to_string(screenId_)); + using RSRcdManager = RSSingleton; + std::vector> rcdLayerInfoList; + for (const auto& layer : layers) { + if (layer == nullptr) { + continue; + } + if (layer->GetCompositionType() == GraphicCompositionType::GRAPHIC_COMPOSITION_DEVICE || + layer->GetCompositionType() == GraphicCompositionType::GRAPHIC_COMPOSITION_DEVICE_CLEAR || + layer->GetCompositionType() == GraphicCompositionType::GRAPHIC_COMPOSITION_SOLID_COLOR) { + continue; + } + auto layerSurface = layer->GetSurface(); + if (layerSurface != nullptr) { + auto rcdlayerInfo = RSRcdManager::GetInstance().GetLayerPair(layerSurface->GetName()); + if (rcdlayerInfo.second != RoundCornerDisplayManager::RCDLayerType::INVALID) { + rcdLayerInfoList.push_back(rcdlayerInfo); + continue; + } + } else { + RS_LOGE("RedrawScreenRCD layerSurface is nullptr"); + continue; + } + } + + if (RSRcdManager::GetInstance().GetRcdEnable()) { + RSRcdManager::GetInstance().DrawRoundCorner(rcdLayerInfoList, &canvas); + } +} + void RSRenderComposer::Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId) { + RS_TRACE_NAME("RSHardwareThread::Redraw, threadId: " + std::to_string(screenId_)); + // 需适配 + std::unique_lock lock(preAllocMutex_, std::try_to_lock); + auto screenManager = CreateOrGetScreenManager(); + if (screenManager == nullptr) { + RS_LOGE("Redraw: screenManager is null."); + return; + } + if (surface == nullptr || uniRenderEngine_ == nullptr) { + RS_LOGE("Redraw: surface or uniRenderEngine is null."); + return; + } + bool isProtected = false; + + static bool isCCMDrmEnabled = DRMParam::IsDrmEnable(); + bool isDrmEnabled = RSSystemProperties::GetDrmEnabled() && isCCMDrmEnabled; + +#ifdef RS_ENABLE_VK + if (RSSystemProperties::GetGpuApiType() == GpuApiType::VULKAN || + RSSystemProperties::GetGpuApiType() == GpuApiType::DDGR) { + if (isDrmEnabled) { + for (const auto& layer : layers) { + if (layer && layer->GetBuffer() && (layer->GetBuffer()->GetUsage() & BUFFER_USAGE_PROTECTED)) { + isProtected = true; + break; + } + } + if (RSSystemProperties::IsUseVulkan()) { + RsVulkanContext::GetSingleton().SetIsProtected(isProtected); + } + } else { + RsVulkanContext::GetSingleton().SetIsProtected(false); + } + } +#endif + + RS_LOGD("RsDebug Redraw flush frame buffer start"); + bool forceCPU = RSBaseRenderEngine::NeedForceCPU(layers); + auto screenInfo = screenManager->QueryScreenInfo(screenId); + std::shared_ptr drawingColorSpace = nullptr; +#ifdef USE_VIDEO_PROCESSING_ENGINE + GraphicColorGamut colorGamut = ComputeTargetColorGamut(layers); + 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", + colorGamut, pixelFormat, screenInfo.phyWidth, screenInfo.phyHeight); + auto renderFrameConfig = RSBaseRenderUtil::GetFrameBufferRequestConfig(screenInfo, + isProtected, colorGamut, pixelFormat); + drawingColorSpace = RSBaseRenderEngine::ConvertColorGamutToDrawingColorSpace(colorGamut); + // set color space to surface buffer metadata + using namespace HDI::Display::Graphic::Common::V1_0; + CM_ColorSpaceType colorSpace = CM_SRGB_FULL; + if (ConvertColorGamutToSpaceType(colorGamut, colorSpace)) { + if (surface->SetUserData("ATTRKEY_COLORSPACE_INFO", std::to_string(colorSpace)) != GSERROR_OK) { + RS_LOGD("Redraw set user data failed"); + } + } +#else + auto renderFrameConfig = RSBaseRenderUtil::GetFrameBufferRequestConfig(screenInfo, isProtected); +#endif + // override redraw frame buffer with physical screen resolution. + renderFrameConfig.width = static_cast(screenInfo.phyWidth); + renderFrameConfig.height = static_cast(screenInfo.phyHeight); + + std::shared_ptr frameBufferSurfaceOhos; + auto surfaceId = surface->GetUniqueId(); + { + std::lock_guard lock(frameBufferSurfaceOhosMapMutex_); + if (frameBufferSurfaceOhosMap_.count(surfaceId)) { + frameBufferSurfaceOhos = frameBufferSurfaceOhosMap_[surfaceId]; + } else { + frameBufferSurfaceOhos = CreateFrameBufferSurfaceOhos(surface); + frameBufferSurfaceOhosMap_[surfaceId] = frameBufferSurfaceOhos; + } + } + FrameContextConfig frameContextConfig = {isProtected, false}; +#ifdef RS_ENABLE_VKQUEUE_PRIORITY + frameContextConfig.independentContext = RSSystemProperties::GetVkQueuePriorityEnable(); +#endif + std::lock_guard ohosSurfaceLock(surfaceMutex_); + auto renderFrame = uniRenderEngine_->RequestFrame(frameBufferSurfaceOhos, renderFrameConfig, + forceCPU, true, frameContextConfig); + if (renderFrame == nullptr) { + RS_LOGE("RsDebug Redraw failed to request frame."); + return; + } + auto canvas = renderFrame->GetCanvas(); + if (canvas == nullptr) { + RS_LOGE("RsDebug Redraw canvas is nullptr."); + return; + } +#ifdef RS_ENABLE_VK + if (RSSystemProperties::IsUseVulkan()) { + canvas->Clear(Drawing::Color::COLOR_TRANSPARENT); + } +#endif +#ifdef USE_VIDEO_PROCESSING_ENGINE + uniRenderEngine_->DrawLayers(*canvas, layers, false, screenInfo, colorGamut); +#else + uniRenderEngine_->DrawLayers(*canvas, layers, false, screenInfo); +#endif + RedrawScreenRCD(*canvas, layers); +#ifdef RS_ENABLE_TV_PQ_METADATA + auto rsSurface = renderFrame->GetSurface(); + RSTvMetadataManager::Instance().CopyFromLayersToSurface(layers, rsSurface); +#endif + renderFrame->Flush(); + RS_LOGD("RsDebug Redraw flush frame buffer end"); } void RSRenderComposer::OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data) -- Gitee From defcb2b6494afd77afcd45e3d15d6bd7d593dcb5 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Thu, 24 Jul 2025 11:23:41 +0000 Subject: [PATCH 09/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../base/include/rs_render_composer.h | 9 ++- .../base/src/rs_render_compositor.cpp | 77 +++++++++++++++++-- .../hardware_thread/rs_hardware_thread.h | 1 + 3 files changed, 80 insertions(+), 7 deletions(-) diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/base/include/rs_render_composer.h index fa6ef0a612..d94cb0454e 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer.h @@ -15,14 +15,18 @@ */ #ifndef RS_RENDER_COMPOSER_H #define RS_RENDER_COMPOSER_H - #include +#include + #include "event_handler.h" #include "feature/hyper_graphic_manager/hgm_hardware_utils.h" #include "hdi_backend.h" +#include "hgm_core.h" #include "pipeline/main_thread/rs_main_thread.h" -#include "pipeline/render_thread/rs_uni_render_engine.h" #include "rs_render_composer_context.h" +#ifdef RES_SCHED_ENABLE +#include "vsync_system_ability_listener.h" +#endif namespace OHOS::Rosen { using UniFallbackCallback = std::function& surface, const std::vector& layers, @@ -94,6 +98,7 @@ private: std::shared_ptr handler_ = nullptr; HdiBackend* hdiBackend_ = nullptr; OutputPtr hdiOutput_; + sptr releaseFence_ = SyncFence::InvalidFence(); int32_t threadTid_ = -1; ScreenId screenId_; std::shared_ptr rsRenderComposerContext_; diff --git a/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp b/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp index 124896188f..752b798110 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp @@ -13,21 +13,88 @@ * limitations under the License. */ #include "rs_render_compositor.h" + #include #include + +#include "frame_report.h" +#include "hdi_backend.h" +#include "hgm_frame_rate_manager.h" +#include "hisysevent.h" +#include "parameters.h" +#include "pipeline/hardware_thread/rs_realtime_refresh_rate_manager.h" +#include "rs_trace.h" +#include "vsync_sampler.h" + #include "common/rs_exception_check.h" +#include "common/rs_optional_trace.h" #include "common/rs_singleton.h" -#include "gfx/fps_info/rs_surface_fps_manager.h" -#include "gfx/first_frame_notifier/rs_first_frame_notifier.h" -#include "hgm_core.h" +#include "feature/hdr/rs_hdr_util.h" +#include "feature/round_corner_display/rs_round_corner_display_manager.h" +#include "pipeline/render_thread/rs_base_render_util.h" +#include "pipeline/main_thread/rs_main_thread.h" +#include "pipeline/render_thread/rs_uni_render_engine.h" +#include "pipeline/render_thread/rs_uni_render_thread.h" +#include "pipeline/render_thread/rs_uni_render_util.h" #include "platform/common/rs_log.h" #include "platform/common/rs_system_properties.h" -#include "rs_trace.h" -#include "vsync_sampler.h" +#include "platform/ohos/backend/rs_surface_ohos_gl.h" +#include "platform/ohos/backend/rs_surface_ohos_raster.h" +#include "screen_manager/rs_screen_manager.h" +#include "gfx/fps_info/rs_surface_fps_manager.h" +#include "gfx/first_frame_notifier/rs_first_frame_notifier.h" +#include "platform/common/rs_hisysevent.h" +#include "graphic_feature_param_manager.h" + +#ifdef RS_ENABLE_EGLIMAGE +#ifdef USE_M133_SKIA +#include "src/gpu/ganesh/gl/GrGLDefines.h" +#else +#include "src/gpu/gl/GrGLDefines.h" +#endif +#endif + +#ifdef RS_ENABLE_VK +#include "platform/ohos/backend/rs_surface_ohos_vulkan.h" +#include "feature/gpuComposition/rs_vk_image_manager.h" +#endif + +#ifdef RS_ENABLE_EGLIMAGE +#include "feature/gpuComposition/rs_egl_image_manager.h" +#endif // RS_ENABLE_EGLIMAGE + +#ifdef USE_VIDEO_PROCESSING_ENGINE +#include "metadata_helper.h" +#endif + +#ifdef RES_SCHED_ENABLE +#include "system_ability_definition.h" +#include "if_system_ability_manager.h" +#include +#include "ressched_event_listener.h" +#endif + +#ifdef RS_ENABLE_TV_PQ_METADATA +#include "feature/tv_metadata/rs_tv_metadata_manager.h" +#endif + +#undef LOG_TAG +#define LOG_TAG "RSHardwareThread" namespace OHOS { namespace Rosen { namespace { +constexpr uint32_t HARDWARE_THREAD_TASK_NUM = 2; +constexpr uint32_t HARD_JANK_TWO_TIME = 2; +constexpr int64_t REFRESH_PERIOD = 16667; // 16667us == 16.667ms +constexpr int64_t REPORT_LOAD_WARNING_INTERVAL_TIME = 5000000; // 5s == 5000000us +constexpr int64_t RESERVE_TIME = 1000000; // we reserve 1ms more for the composition +constexpr int64_t COMMIT_DELTA_TIME = 2; // 2ms +constexpr int64_t MAX_DELAY_TIME = 100; // 100ms +constexpr int64_t NS_MS_UNIT_CONVERSION = 1000000; +constexpr int64_t UNI_RENDER_VSYNC_OFFSET_DELAY_MODE = 3300000; // 3.3ms +constexpr uint32_t MAX_TOTAL_SURFACE_NAME_LENGTH = 320; +constexpr uint32_t MAX_SINGLE_SURFACE_NAME_LENGTH = 20; // Threshold for abnormal time in the hardware pipeline constexpr int HARDWARE_TIMEOUT = 800; // The number of exceptions in the hardware pipeline required to achieve render_service reset diff --git a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h index 88e440fae8..44a2b6722a 100644 --- a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h +++ b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h @@ -51,6 +51,7 @@ public: #endif return std::move(taskFuture); } + uint32_t GetunExecuteTaskNum(); void RefreshRateCounts(std::string& dumpString); void ClearRefreshRateCounts(std::string& dumpString); -- Gitee From 11cfb28568b03d8e33446cf912372609c0bfe092 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Thu, 24 Jul 2025 11:25:08 +0000 Subject: [PATCH 10/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../core/pipeline/hardware_thread/rs_hardware_thread.h | 1 - 1 file changed, 1 deletion(-) diff --git a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h index 44a2b6722a..88e440fae8 100644 --- a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h +++ b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_hardware_thread.h @@ -51,7 +51,6 @@ public: #endif return std::move(taskFuture); } - uint32_t GetunExecuteTaskNum(); void RefreshRateCounts(std::string& dumpString); void ClearRefreshRateCounts(std::string& dumpString); -- Gitee From d07301b9d195ccc7a3c759fcf08ef7b725c4d78f Mon Sep 17 00:00:00 2001 From: m00472246 Date: Thu, 24 Jul 2025 12:06:12 +0000 Subject: [PATCH 11/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- rosen/modules/render_service/BUILD.gn | 3 ++- .../composer/base/include/rs_render_composer.h | 3 ++- .../composer/base/include/rs_render_composer_agent.h | 4 ++-- .../composer/base/include/rs_render_composer_context.h | 7 ++++--- .../composer/base/include/rs_render_composer_manager.h | 2 +- .../{rs_render_compositor.cpp => rs_render_composer.cpp} | 6 +++--- .../composer/base/src/rs_render_composer_context.cpp | 8 ++++---- 7 files changed, 18 insertions(+), 15 deletions(-) rename rosen/modules/render_service/composer/base/src/{rs_render_compositor.cpp => rs_render_composer.cpp} (99%) diff --git a/rosen/modules/render_service/BUILD.gn b/rosen/modules/render_service/BUILD.gn index 8941ecfa82..3c1b0256f0 100644 --- a/rosen/modules/render_service/BUILD.gn +++ b/rosen/modules/render_service/BUILD.gn @@ -283,7 +283,7 @@ ohos_shared_library("librender_service") { ] #composer sources += [ - "composer/base/src/rs_render_composer_agnet.cpp", + "composer/base/src/rs_render_composer_agent.cpp", "composer/base/src/rs_render_composer_context.cpp", "composer/base/src/rs_render_composer_manager.cpp", "composer/base/src/rs_render_composer.cpp", @@ -346,6 +346,7 @@ ohos_shared_library("librender_service") { } include_dirs = [ + "composer/base/include", "core", "core/feature_cfg", "core/feature_cfg/feature_param", diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/base/include/rs_render_composer.h index d94cb0454e..61c98b0297 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer.h @@ -85,6 +85,7 @@ private: void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); + template> std::future ScheduleTask(Task&& task) { auto [scheduledTask, taskFuture] = Detail::ScheduledTask::Create(std::forward(task)); @@ -110,6 +111,6 @@ private: std::atomic unExecuteTaskNum_ = 0; int hardwareCount_ = 0; ExceptionCheck exceptionCheck_; -} +}; } // namespace OHOS #endif // RS_RENDER_COMPOSER_H \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h index 37d51b29ed..2c2017d900 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h @@ -31,8 +31,8 @@ public: void DeleteComposerLayer(); void ComposerFrame(); -prvate: +private: std::shared_ptr rsRenderComposer_; -} +}; } // namespace OHOS #endif // RS_RENDER_COMPOSER_THREAD_AGENT_H \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h index 130f987a45..aab45827a2 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h @@ -17,9 +17,10 @@ #ifndef RS_RENDER_COMPOSER_CONTEXT_H #define RS_RENDER_COMPOSER_CONTEXT_H +#include "common/rs_common_def.h" #include "hdi_layer.h" #include "hdi_layer_info.h" -#include "rs_render_layer.h" +// #include "rs_render_layer.h" namespace OHOS::Rosen { class RSRenderComposerContext { @@ -32,12 +33,12 @@ public: void UpdateRenderLayer(); void DeleteRenderLayer(); - std::unordered_map>& GetLayersMap(); + // std::unordered_map>& GetLayersMap(); std::vector& GetLayersVec(); private: std::unordered_map> layersMap_; std::vector layersVec_; -} +}; } // namespace OHOS #endif // RS_RENDER_COMPOSER_CONTEXT_H \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h index f96ea3427a..caf689b06a 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h @@ -37,6 +37,6 @@ private: std::unordered_map> rsRenderComposerMap_; std::shared_ptr handler_ = nullptr; std::mutex mutex_; -} +}; } // namespace OHOS #endif // RS_RENDER_COMPOSER_THREAD_MANAGER_H \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp similarity index 99% rename from rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp rename to rosen/modules/render_service/composer/base/src/rs_render_composer.cpp index 752b798110..452ac2ceb6 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_compositor.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp @@ -12,7 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "rs_render_compositor.h" +#include "rs_render_composer.h" #include #include @@ -207,8 +207,8 @@ void RSRenderComposer::PrepareComposeFrame(RefreshRateParam& param, uint32_t& cu bool& hasGameScene, ScreenId& curScreenId, int64_t& delayTime) { // 需适配 - LayerComposeCollection::GetInstance().UpdateUniformOrOfflineComposeFrameNumberForDFX( - rsRenderComposerContext_->GetLayersMap().size()); + // LayerComposeCollection::GetInstance().UpdateUniformOrOfflineComposeFrameNumberForDFX( + // rsRenderComposerContext_->GetLayersMap().size()); hgmHardwareUtils_.UpdateRefreshRateParam(); param = hgmHardwareUtils_.GetRefreshRateParam(); diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp index 776a0e5170..ce394f67e2 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp @@ -31,10 +31,10 @@ void RSRenderComposerContext::DeleteRenderLayer() } -std::unordered_map>& RSRenderComposerContext::GetLayersMap() -{ - return layersMap_; -} +// std::unordered_map>& RSRenderComposerContext::GetLayersMap() +// { +// return layersMap_; +// } std::vector RSRenderComposerContext::GetLayersVec() { -- Gitee From e742b5ae6018e14adf3520231d09a58d43d53264 Mon Sep 17 00:00:00 2001 From: m00472246 Date: Thu, 24 Jul 2025 12:38:03 +0000 Subject: [PATCH 12/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../base/include/rs_render_composer.h | 7 +++ .../base/include/rs_render_composer_context.h | 2 +- .../base/include/rs_render_composer_manager.h | 6 +- .../composer/base/src/rs_render_composer.cpp | 57 ++++++++++++++++--- .../rs_realtime_refresh_rate_manager.h | 1 + 5 files changed, 61 insertions(+), 12 deletions(-) diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/base/include/rs_render_composer.h index 61c98b0297..80a2dfb2be 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer.h @@ -80,6 +80,11 @@ private: HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType& colorSpaceInfo); #endif void RedrawScreenRCD(RSPaintFilterCanvas& canvas, const std::vector& layers); + void ContextRegisterPostTask(); +#ifdef RES_SCHED_ENABLE + void SubScribeSystemAbility(); + sptr saStatusChangeListener_ = nullptr; +#endif uint32_t GetUnExecuteTaskNum(); void IncUnExecuteTaskNum(); @@ -111,6 +116,8 @@ private: std::atomic unExecuteTaskNum_ = 0; int hardwareCount_ = 0; ExceptionCheck exceptionCheck_; + std::map refreshRateCounts_; + int64_t lastActualTime_ = 0; }; } // namespace OHOS #endif // RS_RENDER_COMPOSER_H \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h index aab45827a2..c8b42e6407 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h @@ -37,7 +37,7 @@ public: std::vector& GetLayersVec(); private: - std::unordered_map> layersMap_; + // std::unordered_map> layersMap_; std::vector layersVec_; }; } // namespace OHOS diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h index caf689b06a..8973bd434b 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h @@ -20,10 +20,10 @@ #include "rs_render_composer.h" namespace OHOS::Rosen { -class RSRenderComposerThreadManager { +class RSRenderComposerManager { public: - RSRenderComposerThreadManager(std::shared_ptr& handler); - ~RSRenderComposerThreadManager() = default; + RSRenderComposerManager(std::shared_ptr& handler); + ~RSRenderComposerManager() = default; void OnScreenConnect(OutputPtr& output); void OnScreenDisconnect(OutputPtr& output); void OnScreenChange(OutputPtr& output); diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp index 452ac2ceb6..d11ef7054c 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp @@ -168,17 +168,17 @@ void RSRenderComposer::init(OutputPtr& output) } } -void RSRenderComposer::AddRenderLayer(NodeId layerId) +void RSRenderComposer::AddComposerLayer() { } -void RSRenderComposer::UpdateRenderLayer(NodeId layerId) +void RSRenderComposer::UpdateComposerLayer() { } -void RSRenderComposer::DeleteRenderLayer(NodeId layerId) +void RSRenderComposer::DeleteComposerLayer() { } @@ -213,7 +213,7 @@ void RSRenderComposer::PrepareComposeFrame(RefreshRateParam& param, uint32_t& cu hgmHardwareUtils_.UpdateRefreshRateParam(); param = hgmHardwareUtils_.GetRefreshRateParam(); // 需适配 - auto hgmCore = OHOS::Rosen::HgmCore::Instance(); + auto& hgmCore = OHOS::Rosen::HgmCore::Instance(); curScreenId = hgmCore.GetActiveScreenId(); currentRate = hgmCore.GetScreenCurrentRefreshRate(curScreenId); hasGameScene = FrameReport::GetInstance().HasGameScene(); @@ -399,7 +399,7 @@ void RSRenderComposer::AddRefreshRateCount(const OutputPtr& output) frameRateMgr->HandleRsFrame(); } -void RSHardwareThread::RecordTimestamp(const std::vector& layers) +void RSRenderComposer::RecordTimestamp(const std::vector& layers) { uint64_t currentTime = static_cast( std::chrono::duration_cast( @@ -465,7 +465,7 @@ void RSRenderComposer::ProcessComposeFrame(RefreshRateParam param, uint32_t curr RSTimer rsTimer(threadName.c_str(), HARDWARE_TIMEOUT); auto layers = rsRenderComposerContext_->GetLayersVec(); -ifdef HIPERF_TRACE_ENABLE +#ifdef HIPERF_TRACE_ENABLE RS_LOGW("hiperf_surface_counter3 %{public}" PRIu64 " ", static_cast(layers.size())); #endif int64_t startTime = GetCurTimeCount(); @@ -519,10 +519,10 @@ ifdef HIPERF_TRACE_ENABLE } bool doRepaint = hdiOutput_->IsDeviceValid() && !shouldDropFrame; if (doRepaint) { - hdiBackend_->Repaint(output); + hdiBackend_->Repaint(hdiOutput_); RecordTimestamp(layers); } - output->ReleaseLayers(releaseFence_); + hdiOutput_->ReleaseLayers(releaseFence_); // 需适配 RSBaseRenderUtil::DecAcquiredBufferCount(); RSUniRenderThread::Instance().NotifyScreenNodeBufferReleased(); @@ -989,5 +989,46 @@ void RSRenderComposer::PostDelayTask(const std::function& task, int64_t handler_->PostTask(task, delayTime, AppExecFwk::EventQueue::Priority::IMMEDIATE); } } + +void RSRenderComposer::SubScribeSystemAbility() +{ + RS_LOGI("%{public}s", __func__); + // 需适配 + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (!systemAbilityManager) { + RS_LOGE("%{public}s failed to get system ability manager client", __func__); + return; + } + std::string threadName = "RSHardwareThread"; + std::string strUid = std::to_string(getuid()); + std::string strPid = std::to_string(getpid()); + std::string strTid = std::to_string(gettid()); + + saStatusChangeListener_ = new (std::nothrow)VSyncSystemAbilityListener(threadName, strUid, strPid, strTid); + int32_t ret = systemAbilityManager->SubscribeSystemAbility(RES_SCHED_SYS_ABILITY_ID, saStatusChangeListener_); + if (ret != ERR_OK) { + RS_LOGE("%{public}s subscribe system ability %{public}d failed.", __func__, RES_SCHED_SYS_ABILITY_ID); + saStatusChangeListener_ = nullptr; + } +} + +void RSRenderComposer::ContextRegisterPostTask() +{ + // 需适配 +#if defined(RS_ENABLE_VK) && defined(IS_ENABLE_DRM) + if (RSSystemProperties::IsUseVulkan()) { + RsVulkanContext::GetSingleton().SetIsProtected(true); + auto context = RsVulkanContext::GetSingleton().GetDrawingContext(); + if (context) { + context->RegisterPostFunc([this](const std::function& task) { PostTask(task); }); + } + RsVulkanContext::GetSingleton().SetIsProtected(false); + if (context) { + context->RegisterPostFunc([this](const std::function& task) { PostTask(task); }); + } + } +#endif +} } // namespace Rosen } // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_realtime_refresh_rate_manager.h b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_realtime_refresh_rate_manager.h index e439c37796..d491e86431 100644 --- a/rosen/modules/render_service/core/pipeline/hardware_thread/rs_realtime_refresh_rate_manager.h +++ b/rosen/modules/render_service/core/pipeline/hardware_thread/rs_realtime_refresh_rate_manager.h @@ -46,6 +46,7 @@ public: uint32_t GetRealtimeRefreshRate(ScreenId screenId); private: friend class RSHardwareThread; + friend class RSRenderComposer; RSRealtimeRefreshRateManager() = default; ~RSRealtimeRefreshRateManager() = default; -- Gitee From ebb23149d474bb3ebfdba2754407624c111f3aed Mon Sep 17 00:00:00 2001 From: m00472246 Date: Fri, 25 Jul 2025 02:18:39 +0000 Subject: [PATCH 13/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../base/include/rs_render_composer.h | 10 ++++- .../base/include/rs_render_composer_context.h | 6 +-- .../base/include/rs_render_composer_manager.h | 6 +-- .../composer/base/src/rs_render_composer.cpp | 40 ++++++++++++++----- .../base/src/rs_render_composer_context.cpp | 10 ++--- .../base/src/rs_render_composer_manager.cpp | 12 +++--- 6 files changed, 54 insertions(+), 30 deletions(-) diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/base/include/rs_render_composer.h index 80a2dfb2be..69261e52ad 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer.h @@ -34,7 +34,7 @@ using UniFallbackCallback = std::function& surface, con class ScheduledTask; class RSRenderComposer { public: - RSRenderComposer(OutputPtr& output); + RSRenderComposer(const OutputPtr& output); ~RSRenderComposer() = default; // 维护layer @@ -55,7 +55,7 @@ private: void ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId); void CompleteComposeFrame(); - void init(OutputPtr& output); + void init(const OutputPtr& output); void Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId); void OnPrepareComplete(sptr& surface, const PrepareCompleteParam& param, void* data); void UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRateParam param, @@ -85,6 +85,7 @@ private: void SubScribeSystemAbility(); sptr saStatusChangeListener_ = nullptr; #endif + std::shared_ptr CreateFrameBufferSurfaceOhos(const sptr& surface); uint32_t GetUnExecuteTaskNum(); void IncUnExecuteTaskNum(); @@ -111,6 +112,10 @@ private: std::shared_ptr uniRenderEngine_; HgmHardwareUtils hgmHardwareUtils_; UniFallbackCallback redrawCb_; + std::mutex preAllocMutex_; + std::mutex surfaceMutex_; + std::mutex frameBufferSurfaceOhosMapMutex_; + std::unordered_map> frameBufferSurfaceOhosMap_; int64_t delayTime_ = 0; int64_t lastCommitTime_ = 0; std::atomic unExecuteTaskNum_ = 0; @@ -118,6 +123,7 @@ private: ExceptionCheck exceptionCheck_; std::map refreshRateCounts_; int64_t lastActualTime_ = 0; + int64_t intervalTimePoints_ = 0; }; } // namespace OHOS #endif // RS_RENDER_COMPOSER_H \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h index c8b42e6407..22db5785b4 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h @@ -29,9 +29,9 @@ public: ~RSRenderComposerContext() = default; // 维护layer - void AddRenderLayer(); - void UpdateRenderLayer(); - void DeleteRenderLayer(); + void AddComposerLayer(); + void UpdateComposerLayer(); + void DeleteComposerLayer(); // std::unordered_map>& GetLayersMap(); std::vector& GetLayersVec(); diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h index 8973bd434b..15d2ce6f0f 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h @@ -24,9 +24,9 @@ class RSRenderComposerManager { public: RSRenderComposerManager(std::shared_ptr& handler); ~RSRenderComposerManager() = default; - void OnScreenConnect(OutputPtr& output); - void OnScreenDisconnect(OutputPtr& output); - void OnScreenChange(OutputPtr& output); + void OnScreenConnect(const OutputPtr& output); + void OnScreenDisconnect(const OutputPtr& output); + void OnScreenChange(const OutputPtr& output); std::shared_ptr GetRSRenderComposer(ScreenId screenId); void PostTask(const std::function& task); diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp index d11ef7054c..7e4240305d 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp @@ -112,12 +112,12 @@ static int64_t SystemTime() return int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec; // 1000000000ns == 1s } -RSRenderComposer::RSRenderComposer(OutputPtr& output) +RSRenderComposer::RSRenderComposer(const OutputPtr& output) { init(output); } -void RSRenderComposer::init(OutputPtr& output) +void RSRenderComposer::init(const OutputPtr& output) { if (output == nullptr) { RS_LOGE("RSRenderComposer init output is nullptr"); @@ -126,7 +126,7 @@ void RSRenderComposer::init(OutputPtr& output) hdiBackend_ = HdiBackend::GetInstance(); hdiOutput_ = output; screenId_ = hdiOutput_->GetScreenId(); - RS_LOGI("Start RSRendeComposerThread, screenId : %{public}u", screenId_); + RS_LOGI("Start RSRendeComposerThread, screenId : %{public}llu", screenId_); std::string threadName = "RSRendeComposerThread_" + std::to_string(screenId_); runner_ = AppExecFwk::EventRunner::Create(threadName); handler_ = std::make_shared(runner_); @@ -134,7 +134,7 @@ void RSRenderComposer::init(OutputPtr& output) redrawCb_ = [this](const sptr& surface, const std::vector& layers, uint32_t screenId) { return this->Redraw(surface, layers, screenId); }; - rsRenderComposerContext_ = std::make_shared(); + rsRenderComposerContext_ = std::make_shared(); if (handler_) { ScheduleTask( @@ -557,7 +557,7 @@ void RSRenderComposer::ProcessComposeFrame(RefreshRateParam param, uint32_t curr "FRAME_RATE", frameRate, "MISSED_FRAMES", missedFrames, "FRAME_TIME", frameTime); } - EndCheck(timer); + EndCheck(rsTimer); } void RSRenderComposer::CompleteComposeFrame() @@ -718,7 +718,7 @@ void RSRenderComposer::UpdateDelayTime(OHOS::Rosen::HgmCore& hgmCore, RefreshRat } #ifdef USE_VIDEO_PROCESSING_ENGINE -GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const std::vector& layers) +GraphicColorGamut RSRenderComposer::ComputeTargetColorGamut(const std::vector& layers) { using namespace HDI::Display::Graphic::Common::V1_0; GraphicColorGamut colorGamut = GRAPHIC_COLOR_GAMUT_SRGB; @@ -750,7 +750,7 @@ GraphicColorGamut RSHardwareThread::ComputeTargetColorGamut(const std::vector& layers) +GraphicPixelFormat RSRenderComposer::ComputeTargetPixelFormat(const std::vector& layers) { using namespace HDI::Display::Graphic::Common::V1_0; GraphicPixelFormat pixelFormat = GRAPHIC_PIXEL_FMT_RGBA_8888; @@ -784,7 +784,7 @@ GraphicPixelFormat RSHardwareThread::ComputeTargetPixelFormat(const std::vector< return pixelFormat; } -bool RSHardwareThread::ConvertColorGamutToSpaceType(const GraphicColorGamut& colorGamut, +bool RSRenderComposer::ConvertColorGamutToSpaceType(const GraphicColorGamut& colorGamut, HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType& colorSpaceType) { using namespace HDI::Display::Graphic::Common::V1_0; @@ -809,9 +809,9 @@ bool RSHardwareThread::ConvertColorGamutToSpaceType(const GraphicColorGamut& col } #endif -void RSHardwareThread::RedrawScreenRCD(RSPaintFilterCanvas& canvas, const std::vector& layers) +void RSRenderComposer::RedrawScreenRCD(RSPaintFilterCanvas& canvas, const std::vector& layers) { - RS_TRACE_NAME("RSHardwareThread::RedrawScreenRCD， threadId: " + std::to_string(screenId_)); + RS_TRACE_NAME("RSHardwareThread::RedrawScreenRCD, threadId: " + std::to_string(screenId_)); using RSRcdManager = RSSingleton; std::vector> rcdLayerInfoList; for (const auto& layer : layers) { @@ -841,6 +841,24 @@ void RSHardwareThread::RedrawScreenRCD(RSPaintFilterCanvas& canvas, const std::v } } +std::shared_ptr RSRenderComposer::CreateFrameBufferSurfaceOhos(const sptr& surface) +{ + std::shared_ptr rsSurface = nullptr; +#if (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE) + if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) { + rsSurface = std::make_shared(surface); + } +#endif +#if (defined RS_ENABLE_VK) + if (RSSystemProperties::GetGpuApiType() == GpuApiType::VULKAN || + RSSystemProperties::GetGpuApiType() == GpuApiType::DDGR) { + rsSurface = std::make_shared(surface); + } +#endif + RS_LOGD("Redraw: CreateFrameBufferSurfaceOhos."); + return rsSurface; +} + void RSRenderComposer::Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId) { @@ -1031,4 +1049,4 @@ void RSRenderComposer::ContextRegisterPostTask() #endif } } // namespace Rosen -} // namespace OHOSl \ No newline at end of file +} // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp index ce394f67e2..01a296967b 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp @@ -16,17 +16,17 @@ namespace OHOS { namespace Rosen { -void RSRenderComposerContext::AddRenderLayer() +void RSRenderComposerContext::AddComposerLayer() { } -void RSRenderComposerContext::UpdateRenderLayer() +void RSRenderComposerContext::UpdateComposerLayer() { } -void RSRenderComposerContext::DeleteRenderLayer() +void RSRenderComposerContext::DeleteComposerLayer() { } @@ -36,9 +36,9 @@ void RSRenderComposerContext::DeleteRenderLayer() // return layersMap_; // } -std::vector RSRenderComposerContext::GetLayersVec() +std::vector& RSRenderComposerContext::GetLayersVec() { - + return layersVec_; } } // namespace Rosen } // namespace OHOSl \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp index a5cba1133d..4daa672056 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp @@ -24,7 +24,7 @@ RSRenderComposerManager::RSRenderComposerManager(std::shared_ptr RSRenderComposerManager::GetRSRenderComposerThread(ScreenId screenId) +std::shared_ptr RSRenderComposerManager::GetRSRenderComposer(ScreenId screenId) { std::lock_guard lock(mutex_); auto iter = rsRenderComposerMap_.find(screenId); if (iter == rsRenderComposerMap_.end()) { - RS_LOGE("Not find screenId: %{public}u", screenId); + RS_LOGE("Not find screenId: %{public}llu", screenId); return nullptr; } - return iter->sencond; + return iter->second; } void RSRenderComposerManager::PostTask(const std::function& task) -- Gitee From 5823e647a18608929b2cdfc7c763fb12f007478d Mon Sep 17 00:00:00 2001 From: m00472246 Date: Fri, 25 Jul 2025 07:27:59 +0000 Subject: [PATCH 14/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- .../composer/base/include/rs_render_composer.h | 3 +-- .../render_service/composer/base/src/rs_render_composer.cpp | 5 ----- 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/base/include/rs_render_composer.h index 69261e52ad..fd9546e625 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/base/include/rs_render_composer.h @@ -44,6 +44,7 @@ public: void ComposerFrame(); int32_t GetHardwareThreadTid() const; + uint32_t GetUnExecuteTaskNum(); private: void PostTask(const std::function& task); void PostSyncTask(const std::function& task); @@ -53,7 +54,6 @@ private: void PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, bool& hasGameScene, ScreenId& curScreenId, int64_t& delayTime); void ProcessComposeFrame(RefreshRateParam param, uint32_t currentRate, bool hasGameScene, ScreenId curScreenId); - void CompleteComposeFrame(); void init(const OutputPtr& output); void Redraw(const sptr& surface, const std::vector& layers, uint32_t screenId); @@ -87,7 +87,6 @@ private: #endif std::shared_ptr CreateFrameBufferSurfaceOhos(const sptr& surface); - uint32_t GetUnExecuteTaskNum(); void IncUnExecuteTaskNum(); void SubUnExecuteTaskNum(); diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp index 7e4240305d..905f5cfed3 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp +++ b/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp @@ -560,11 +560,6 @@ void RSRenderComposer::ProcessComposeFrame(RefreshRateParam param, uint32_t curr EndCheck(rsTimer); } -void RSRenderComposer::CompleteComposeFrame() -{ - -} - void RSRenderComposer::ComposerFrame() { RefreshRateParam param; -- Gitee From abfdb5d86aeeb6f1f929ba38385d8d7df919c58c Mon Sep 17 00:00:00 2001 From: m00472246 Date: Sat, 26 Jul 2025 07:40:59 +0000 Subject: [PATCH 15/15] =?UTF-8?q?=E5=B9=B6=E8=A1=8C=E5=90=88=E6=88=90?= =?UTF-8?q?=E5=A4=9A=E7=BA=BF=E7=A8=8B=E6=A1=86=E6=9E=B6=20Signed-off-by:?= =?UTF-8?q?=20m00472246=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: m00472246 --- rosen/modules/render_service/BUILD.gn | 10 +++--- .../include/rs_render_composer.h | 13 ++++---- .../include/rs_render_composer_agent.h | 7 +--- .../include/rs_render_composer_context.h | 0 .../include/rs_render_composer_manager.h | 0 .../src/rs_render_composer.cpp | 33 +++++++++---------- .../src/rs_render_composer_agent.cpp | 19 ++--------- .../src/rs_render_composer_context.cpp | 0 .../src/rs_render_composer_manager.cpp | 29 ++++++++-------- 9 files changed, 44 insertions(+), 67 deletions(-) rename rosen/modules/render_service/composer/{base => pipeline}/include/rs_render_composer.h (99%) rename rosen/modules/render_service/composer/{base => pipeline}/include/rs_render_composer_agent.h (88%) rename rosen/modules/render_service/composer/{base => pipeline}/include/rs_render_composer_context.h (100%) rename rosen/modules/render_service/composer/{base => pipeline}/include/rs_render_composer_manager.h (100%) rename rosen/modules/render_service/composer/{base => pipeline}/src/rs_render_composer.cpp (98%) rename rosen/modules/render_service/composer/{base => pipeline}/src/rs_render_composer_agent.cpp (70%) rename rosen/modules/render_service/composer/{base => pipeline}/src/rs_render_composer_context.cpp (100%) rename rosen/modules/render_service/composer/{base => pipeline}/src/rs_render_composer_manager.cpp (79%) diff --git a/rosen/modules/render_service/BUILD.gn b/rosen/modules/render_service/BUILD.gn index 3c1b0256f0..a10ff9b70d 100644 --- a/rosen/modules/render_service/BUILD.gn +++ b/rosen/modules/render_service/BUILD.gn @@ -283,10 +283,10 @@ ohos_shared_library("librender_service") { ] #composer sources += [ - "composer/base/src/rs_render_composer_agent.cpp", - "composer/base/src/rs_render_composer_context.cpp", - "composer/base/src/rs_render_composer_manager.cpp", - "composer/base/src/rs_render_composer.cpp", + "composer/pipeline/src/rs_render_composer_agent.cpp", + "composer/pipeline/src/rs_render_composer_context.cpp", + "composer/pipeline/src/rs_render_composer_manager.cpp", + "composer/pipeline/src/rs_render_composer.cpp", ] } @@ -346,7 +346,7 @@ ohos_shared_library("librender_service") { } include_dirs = [ - "composer/base/include", + "composer/pipeline/include", "core", "core/feature_cfg", "core/feature_cfg/feature_param", diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer.h b/rosen/modules/render_service/composer/pipeline/include/rs_render_composer.h similarity index 99% rename from rosen/modules/render_service/composer/base/include/rs_render_composer.h rename to rosen/modules/render_service/composer/pipeline/include/rs_render_composer.h index fd9546e625..3672e8d2fb 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer.h +++ b/rosen/modules/render_service/composer/pipeline/include/rs_render_composer.h @@ -37,18 +37,17 @@ public: RSRenderComposer(const OutputPtr& output); ~RSRenderComposer() = default; - // 维护layer - void AddComposerLayer(); - void UpdateComposerLayer(); - void DeleteComposerLayer(); - - void ComposerFrame(); + void UpdateLayersAndComposerFrame(); int32_t GetHardwareThreadTid() const; uint32_t GetUnExecuteTaskNum(); -private: void PostTask(const std::function& task); void PostSyncTask(const std::function& task); void PostDelayTask(const std::function& task, int64_t delayTime); +private: + // 维护layer + void AddComposerLayer(); + void UpdateComposerLayer(); + void DeleteComposerLayer(); // 合成 void PrepareComposeFrame(RefreshRateParam& param, uint32_t& currentRate, bool& hasGameScene, diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h b/rosen/modules/render_service/composer/pipeline/include/rs_render_composer_agent.h similarity index 88% rename from rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h rename to rosen/modules/render_service/composer/pipeline/include/rs_render_composer_agent.h index 2c2017d900..fa3ede650c 100644 --- a/rosen/modules/render_service/composer/base/include/rs_render_composer_agent.h +++ b/rosen/modules/render_service/composer/pipeline/include/rs_render_composer_agent.h @@ -25,12 +25,7 @@ public: RSRenderComposerAgent(std::shared_ptr rsRenderComposer); ~RSRenderComposerAgent() = default; - // 维护layer - void AddComposerLayer(); - void UpdateComposerLayer(); - void DeleteComposerLayer(); - - void ComposerFrame(); + void UpdateLayersAndComposerFrame(); private: std::shared_ptr rsRenderComposer_; }; diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_context.h b/rosen/modules/render_service/composer/pipeline/include/rs_render_composer_context.h similarity index 100% rename from rosen/modules/render_service/composer/base/include/rs_render_composer_context.h rename to rosen/modules/render_service/composer/pipeline/include/rs_render_composer_context.h diff --git a/rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h b/rosen/modules/render_service/composer/pipeline/include/rs_render_composer_manager.h similarity index 100% rename from rosen/modules/render_service/composer/base/include/rs_render_composer_manager.h rename to rosen/modules/render_service/composer/pipeline/include/rs_render_composer_manager.h diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp b/rosen/modules/render_service/composer/pipeline/src/rs_render_composer.cpp similarity index 98% rename from rosen/modules/render_service/composer/base/src/rs_render_composer.cpp rename to rosen/modules/render_service/composer/pipeline/src/rs_render_composer.cpp index 905f5cfed3..4beb4894ba 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer.cpp +++ b/rosen/modules/render_service/composer/pipeline/src/rs_render_composer.cpp @@ -126,7 +126,7 @@ void RSRenderComposer::init(const OutputPtr& output) hdiBackend_ = HdiBackend::GetInstance(); hdiOutput_ = output; screenId_ = hdiOutput_->GetScreenId(); - RS_LOGI("Start RSRendeComposerThread, screenId : %{public}llu", screenId_); + RS_LOGI("Start RSRendeComposerThread, screenId : %{public}" PRIu64, screenId_); std::string threadName = "RSRendeComposerThread_" + std::to_string(screenId_); runner_ = AppExecFwk::EventRunner::Create(threadName); handler_ = std::make_shared(runner_); @@ -168,21 +168,6 @@ void RSRenderComposer::init(const OutputPtr& output) } } -void RSRenderComposer::AddComposerLayer() -{ - -} - -void RSRenderComposer::UpdateComposerLayer() -{ - -} - -void RSRenderComposer::DeleteComposerLayer() -{ - -} - int32_t RSRenderComposer::GetHardwareThreadTid() const { return threadTid_; @@ -560,7 +545,7 @@ void RSRenderComposer::ProcessComposeFrame(RefreshRateParam param, uint32_t curr EndCheck(rsTimer); } -void RSRenderComposer::ComposerFrame() +void RSRenderComposer::UpdateLayersAndComposerFrame() { RefreshRateParam param; uint32_t currentRate = 0; @@ -571,6 +556,20 @@ void RSRenderComposer::ComposerFrame() std::function task = [this, param = param, currentRate = currentRate, hasGameScene = hasGameScene, curScreenId = curScreenId]() { + // switch () + // { + // case : + // AddComposerLayer(); + // break; + // case : + // UpdateComposerLayer(); + // break; + // case : + // DeleteComposerLayer(); + // break; + // default: + // return; + // } ProcessComposeFrame(param, currentRate, hasGameScene, curScreenId); }; PostDelayTask(task, delayTime); diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer_agent.cpp b/rosen/modules/render_service/composer/pipeline/src/rs_render_composer_agent.cpp similarity index 70% rename from rosen/modules/render_service/composer/base/src/rs_render_composer_agent.cpp rename to rosen/modules/render_service/composer/pipeline/src/rs_render_composer_agent.cpp index 83e22f4bc2..56e03b1f32 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer_agent.cpp +++ b/rosen/modules/render_service/composer/pipeline/src/rs_render_composer_agent.cpp @@ -21,24 +21,9 @@ namespace Rosen { RSRenderComposerAgent::RSRenderComposerAgent(std::shared_ptr rsRenderComposer) : rsRenderComposer_(rsRenderComposer) {} -void RSRenderComposerAgent::AddComposerLayer() +void RSRenderComposerAgent::UpdateLayersAndComposerFrame() { - rsRenderComposer_->AddComposerLayer(); -} - -void RSRenderComposerAgent::UpdateComposerLayer() -{ - rsRenderComposer_->UpdateComposerLayer(); -} - -void RSRenderComposerAgent::DeleteComposerLayer() -{ - rsRenderComposer_->DeleteComposerLayer(); -} - -void RSRenderComposerAgent::ComposerFrame() -{ - rsRenderComposer_->ComposerFrame(); + rsRenderComposer_->UpdateLayersAndComposerFrame(); } } // namespace Rosen } // namespace OHOS \ No newline at end of file diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp b/rosen/modules/render_service/composer/pipeline/src/rs_render_composer_context.cpp similarity index 100% rename from rosen/modules/render_service/composer/base/src/rs_render_composer_context.cpp rename to rosen/modules/render_service/composer/pipeline/src/rs_render_composer_context.cpp diff --git a/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp b/rosen/modules/render_service/composer/pipeline/src/rs_render_composer_manager.cpp similarity index 79% rename from rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp rename to rosen/modules/render_service/composer/pipeline/src/rs_render_composer_manager.cpp index 4daa672056..65172865fc 100644 --- a/rosen/modules/render_service/composer/base/src/rs_render_composer_manager.cpp +++ b/rosen/modules/render_service/composer/pipeline/src/rs_render_composer_manager.cpp @@ -32,10 +32,7 @@ void RSRenderComposerManager::OnScreenConnect(const OutputPtr& output) RS_LOGI("OnScreenConnect screenId: %{public}u", output->GetScreenId()); std::function task = [this, output = output]() { auto renderComposer = std::make_shared(output); - { - std::lock_guard lock(mutex_); - rsRenderComposerMap_.insert(std::pair(output->GetScreenId(), renderComposer)); - } + rsRenderComposerMap_.insert(std::pair(output->GetScreenId(), renderComposer)); }; PostTask(task); } @@ -47,10 +44,7 @@ void RSRenderComposerManager::OnScreenDisconnect(const OutputPtr& output) } RS_LOGI("OnScreenDisconnect screenId: %{public}u", output->GetScreenId()); std::function task = [this, output = output]() { - { - std::lock_guard lock(mutex_); - rsRenderComposerMap_.erase(output->GetScreenId()); - } + rsRenderComposerMap_.erase(output->GetScreenId()); }; PostTask(task); } @@ -62,13 +56,18 @@ void RSRenderComposerManager::OnScreenChange(const OutputPtr& output) std::shared_ptr RSRenderComposerManager::GetRSRenderComposer(ScreenId screenId) { - std::lock_guard lock(mutex_); - auto iter = rsRenderComposerMap_.find(screenId); - if (iter == rsRenderComposerMap_.end()) { - RS_LOGE("Not find screenId: %{public}llu", screenId); - return nullptr; - } - return iter->second; + std::shared_ptr rsRenderComposer = nullptr; + std::function task = [this, screenId = screenId, &rsRenderComposer]() { + auto iter = rsRenderComposerMap_.find(screenId); + if (iter == rsRenderComposerMap_.end()) { + RS_LOGE("Not find screenId: %{public}" PRIu64, screenId); + rsRenderComposer = nullptr; + return; + } + rsRenderComposer = iter->second; + }; + PostSyncTask(task); + return rsRenderComposer; } void RSRenderComposerManager::PostTask(const std::function& task) -- Gitee