• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #ifndef RENDER_SERVICE_CLIENT_CORE_PIPELINE_RS_SCREEN_RENDER_NODE_H
16 #define RENDER_SERVICE_CLIENT_CORE_PIPELINE_RS_SCREEN_RENDER_NODE_H
17 
18 #include <memory>
19 #include <mutex>
20 #include "common/rs_common_def.h"
21 
22 #ifndef ROSEN_CROSS_PLATFORM
23 #include <ibuffer_consumer_listener.h>
24 #include <iconsumer_surface.h>
25 #include <surface.h>
26 #include "sync_fence.h"
27 #endif
28 
29 #include "common/rs_macros.h"
30 #include "common/rs_occlusion_region.h"
31 #include "display_engine/rs_luminance_control.h"
32 #include "memory/rs_memory_track.h"
33 #include "pipeline/rs_render_node.h"
34 #include "pipeline/rs_surface_handler.h"
35 #include <screen_manager/screen_types.h>
36 #include "screen_manager/rs_screen_info.h"
37 #include "platform/drawing/rs_surface.h"
38 
39 namespace OHOS {
40 namespace Rosen {
41 class RSSurfaceRenderNode;
42 typedef void (*ReleaseDmaBufferTask)(uint64_t);
43 
44 class RSB_EXPORT RSScreenRenderNode : public RSRenderNode {
45 public:
46     using WeakPtr = std::weak_ptr<RSScreenRenderNode>;
47     using SharedPtr = std::shared_ptr<RSScreenRenderNode>;
48     static inline constexpr RSRenderNodeType Type = RSRenderNodeType::SCREEN_NODE;
49     explicit RSScreenRenderNode(
50         NodeId id, ScreenId screenId, const std::weak_ptr<RSContext>& context = {});
51     ~RSScreenRenderNode() override;
52     void SetIsOnTheTree(bool flag, NodeId instanceRootNodeId = INVALID_NODEID,
53         NodeId firstLevelNodeId = INVALID_NODEID, NodeId cacheNodeId = INVALID_NODEID,
54         NodeId uifirstRootNodeId = INVALID_NODEID, NodeId screenNodeId = INVALID_NODEID,
55         NodeId logicalDisplayNodeId = INVALID_NODEID) override;
56 
GetScreenId()57     uint64_t GetScreenId() const
58     {
59         return screenId_;
60     }
61 
SetScreenInfo(ScreenInfo info)62     void SetScreenInfo(ScreenInfo info)
63     {
64         // To prevent the damage region from spreading, geometry properties
65         // are set only when no geometry properties are initialized or when
66         // geometry properties change.
67         auto& properties = GetMutableRenderProperties();
68         auto inGeometryProp = std::tuple {info.width, info.height, info.width, info.height};
69         auto curGeometryProp = std::tuple {properties.GetBoundsWidth(), properties.GetBoundsHeight(),
70             properties.GetFrameWidth(), properties.GetFrameHeight()};
71         if ((isGeometryInitialized_ && inGeometryProp != curGeometryProp) || !isGeometryInitialized_) {
72             isGeometryInitialized_ = true;
73             properties.SetBounds({0, 0, info.width, info.height});
74             properties.SetFrame({0, 0, info.width, info.height});
75         }
76         screenInfo_ = std::move(info);
77     }
78 
GetScreenInfo()79     const ScreenInfo& GetScreenInfo() const
80     {
81         return screenInfo_;
82     }
83 
SetScreenRect(RectI rect)84     void SetScreenRect(RectI rect)
85     {
86         screenRect_ = rect;
87     }
88 
GetScreenRect()89     RectI GetScreenRect() const
90     {
91         return screenRect_;
92     }
93 
94     static void SetReleaseTask(ReleaseDmaBufferTask callback);
95 
GetScreenOffsetX()96     int32_t GetScreenOffsetX() const
97     {
98         return screenInfo_.offsetX;
99     }
100 
GetScreenOffsetY()101     int32_t GetScreenOffsetY() const
102     {
103         return screenInfo_.offsetY;
104     }
105 
HasChildCrossNode()106     bool HasChildCrossNode() const
107     {
108         return hasChildCrossNode_;
109     }
110 
SetHasChildCrossNode(bool hasChildCrossNode)111     void SetHasChildCrossNode(bool hasChildCrossNode)
112     {
113         hasChildCrossNode_ = hasChildCrossNode;
114     }
115 
SetIsFirstVisitCrossNodeDisplay(bool isFirstVisitCrossNodeDisplay)116     void SetIsFirstVisitCrossNodeDisplay(bool isFirstVisitCrossNodeDisplay)
117     {
118         isFirstVisitCrossNodeDisplay_ = isFirstVisitCrossNodeDisplay;
119     }
120 
IsFirstVisitCrossNodeDisplay()121     bool IsFirstVisitCrossNodeDisplay() const
122     {
123         return isFirstVisitCrossNodeDisplay_;
124     }
125 
GetFingerprint()126     bool GetFingerprint() const
127     {
128         return hasFingerprint_;
129     }
130 
131     void SetFingerprint(bool hasFingerprint);
132 
133     void CollectSurface(
134         const std::shared_ptr<RSBaseRenderNode>& node, std::vector<RSBaseRenderNode::SharedPtr>& vec,
135         bool isUniRender, bool onlyFirstLevel) override;
136     void QuickPrepare(const std::shared_ptr<RSNodeVisitor>& visitor) override;
137     void Prepare(const std::shared_ptr<RSNodeVisitor>& visitor) override;
138     void Process(const std::shared_ptr<RSNodeVisitor>& visitor) override;
139 
GetType()140     RSRenderNodeType GetType() const override
141     {
142         return RSRenderNodeType::SCREEN_NODE;
143     }
144 
IsMirrorScreen()145     bool IsMirrorScreen() const
146     {
147         return isMirroredScreen_;
148     }
149 
HasMirroredScreenChanged()150     inline bool HasMirroredScreenChanged() const noexcept
151     {
152         return hasMirroredScreenChanged_;
153     }
154 
ResetMirroredScreenChangedFlag()155     inline void ResetMirroredScreenChangedFlag() noexcept
156     {
157         hasMirroredScreenChanged_ = false;
158     }
159 
SetCompositeType(CompositeType type)160     void SetCompositeType(CompositeType type)
161     {
162         compositeType_ = type;
163     }
GetCompositeType()164     CompositeType GetCompositeType() const
165     {
166         return compositeType_;
167     }
168     void SetForceSoftComposite(bool flag);
IsForceSoftComposite()169     bool IsForceSoftComposite() const
170     {
171         return forceSoftComposite_;
172     }
173     void SetMirrorSource(SharedPtr node);
174     void ResetMirrorSource();
175     void SetIsMirrorScreen(bool isMirror);
176     void SetDisplayGlobalZOrder(float zOrder);
177     bool SkipFrame(uint32_t refreshRate, uint32_t skipFrameInterval) override;
GetMirrorSource()178     WeakPtr GetMirrorSource() const
179     {
180         return mirrorSource_;
181     }
182 
HasDisappearingTransition(bool)183     bool HasDisappearingTransition(bool) const override
184     {
185         return false;
186     }
187     // Use in vulkan parallel rendering
SetIsParallelDisplayNode(bool isParallelDisplayNode)188     void SetIsParallelDisplayNode(bool isParallelDisplayNode)
189     {
190         isParallelDisplayNode_ = isParallelDisplayNode;
191     }
192 
IsParallelDisplayNode()193     bool IsParallelDisplayNode() const
194     {
195         return isParallelDisplayNode_;
196     }
197 
GetDirtyManager()198     std::shared_ptr<RSDirtyRegionManager> GetDirtyManager() const
199     {
200         return dirtyManager_;
201     }
202     void UpdateDisplayDirtyManager(int32_t bufferage, bool useAlignedDirtyRegion = false);
203     void ClearCurrentSurfacePos();
UpdateSurfaceNodePos(NodeId id,RectI rect)204     void UpdateSurfaceNodePos(NodeId id, RectI rect)
205     {
206         currentFrameSurfacePos_[id] = rect;
207     }
208 
AddSurfaceNodePosByDescZOrder(NodeId id,RectI rect)209     void AddSurfaceNodePosByDescZOrder(NodeId id, RectI rect)
210     {
211         currentFrameSurfacesByDescZOrder_.emplace_back(id, rect);
212     }
213 
GetLastFrameSurfacePos(NodeId id)214     RectI GetLastFrameSurfacePos(NodeId id)
215     {
216         if (lastFrameSurfacePos_.count(id) == 0) {
217             return {};
218         }
219         return lastFrameSurfacePos_[id];
220     }
221 
GetCurrentFrameSurfacePos(NodeId id)222     RectI GetCurrentFrameSurfacePos(NodeId id)
223     {
224         if (currentFrameSurfacePos_.count(id) == 0) {
225             return {};
226         }
227         return currentFrameSurfacePos_[id];
228     }
229 
GetSurfaceChangedRects()230     const std::vector<RectI> GetSurfaceChangedRects() const
231     {
232         std::vector<RectI> rects;
233         for (const auto& lastFrameSurfacePo : lastFrameSurfacePos_) {
234             if (currentFrameSurfacePos_.find(lastFrameSurfacePo.first) == currentFrameSurfacePos_.end()) {
235                 rects.emplace_back(lastFrameSurfacePo.second);
236             }
237         }
238         for (const auto& currentFrameSurfacePo : currentFrameSurfacePos_) {
239             if (lastFrameSurfacePos_.find(currentFrameSurfacePo.first) == lastFrameSurfacePos_.end()) {
240                 rects.emplace_back(currentFrameSurfacePo.second);
241             }
242         }
243         return rects;
244     }
245 
GetCurAllSurfaces()246     std::vector<RSBaseRenderNode::SharedPtr>& GetCurAllSurfaces()
247     {
248         return curAllSurfaces_;
249     }
250 
251     void UpdateRenderParams() override;
252     void UpdatePartialRenderParams();
253     void UpdateScreenRenderParams();
RecordMainAndLeashSurfaces(RSBaseRenderNode::SharedPtr surface)254     void RecordMainAndLeashSurfaces(RSBaseRenderNode::SharedPtr surface)
255     {
256         curMainAndLeashSurfaceNodes_.push_back(surface);
257     }
GetAllMainAndLeashSurfaces()258     std::vector<RSBaseRenderNode::SharedPtr>& GetAllMainAndLeashSurfaces() { return curMainAndLeashSurfaceNodes_;}
259 
GetCurAllSurfaces(bool onlyFirstLevel)260     std::vector<RSBaseRenderNode::SharedPtr>& GetCurAllSurfaces(bool onlyFirstLevel)
261     {
262         return onlyFirstLevel ? curAllFirstLevelSurfaces_ : curAllSurfaces_;
263     }
264 
GetLogicalDisplayNodeDrawables()265     std::vector<DrawableV2::RSRenderNodeDrawableAdapter::SharedPtr>& GetLogicalDisplayNodeDrawables()
266     {
267         return logicalDisplayNodeDrawables_;
268     }
269 
SetInitMatrix(const Drawing::Matrix & matrix)270     void SetInitMatrix(const Drawing::Matrix& matrix) {
271         initMatrix_ = matrix;
272     }
273 
GetInitMatrix()274     const Drawing::Matrix& GetInitMatrix() const {
275         return initMatrix_;
276     }
277 
GetOffScreenCacheImgForCapture()278     std::shared_ptr<Drawing::Image> GetOffScreenCacheImgForCapture() {
279         return offScreenCacheImgForCapture_;
280     }
SetOffScreenCacheImgForCapture(std::shared_ptr<Drawing::Image> offScreenCacheImgForCapture)281     void SetOffScreenCacheImgForCapture(std::shared_ptr<Drawing::Image> offScreenCacheImgForCapture) {
282         offScreenCacheImgForCapture_ = offScreenCacheImgForCapture;
283     }
284 
SetHasUniRenderHdrSurface(bool hasUniRenderHdrSurface)285     void SetHasUniRenderHdrSurface(bool hasUniRenderHdrSurface)
286     {
287         hasUniRenderHdrSurface_ = hasUniRenderHdrSurface;
288     }
289 
GetHasUniRenderHdrSurface()290     bool GetHasUniRenderHdrSurface() const
291     {
292         return hasUniRenderHdrSurface_ && !GetForceCloseHdr();
293     }
294 
SetIsLuminanceStatusChange(bool isLuminanceStatusChange)295     void SetIsLuminanceStatusChange(bool isLuminanceStatusChange)
296     {
297         isLuminanceStatusChange_ = isLuminanceStatusChange;
298     }
299 
GetIsLuminanceStatusChange()300     bool GetIsLuminanceStatusChange() const
301     {
302         return isLuminanceStatusChange_;
303     }
304 
305     void SetMainAndLeashSurfaceDirty(bool isDirty);
306 
307     void SetForceCloseHdr(bool isForceCloseHdr);
308 
309     bool GetForceCloseHdr() const;
310 
311     void SetHDRPresent(bool hdrPresent);
312 
313     void SetBrightnessRatio(float brightnessRatio);
314 
SetPixelFormat(const GraphicPixelFormat & pixelFormat)315     void SetPixelFormat(const GraphicPixelFormat& pixelFormat)
316     {
317         pixelFormat_ = pixelFormat;
318     }
319 
GetPixelFormat()320     GraphicPixelFormat GetPixelFormat() const
321     {
322         return pixelFormat_;
323     }
324 
GetFirstFrameVirtualScreenInit()325     bool GetFirstFrameVirtualScreenInit() const
326     {
327         return isFirstFrameVirtualScreenInit_;
328     }
329 
SetFirstFrameVirtualScreenInit(bool isFirstFrameVirtualScreenInit)330     void SetFirstFrameVirtualScreenInit(bool isFirstFrameVirtualScreenInit)
331     {
332         isFirstFrameVirtualScreenInit_ = isFirstFrameVirtualScreenInit;
333     }
334 
335     void SetFixVirtualBuffer10Bit(bool isFixVirtualBuffer10Bit);
336 
337     bool GetFixVirtualBuffer10Bit() const;
338 
339     void SetExistHWCNode(bool existHWCNode);
340 
341     bool GetExistHWCNode() const;
342 
343     void SetColorSpace(const GraphicColorGamut& newColorSpace);
344     void UpdateColorSpace(const GraphicColorGamut& newColorSpace);
345     void SelectBestGamut(const std::vector<ScreenColorGamut>& mode);
GetColorSpace()346     GraphicColorGamut GetColorSpace() const
347     {
348         return colorSpace_;
349     }
350 
GetDirtySurfaceNodeMap()351     std::map<NodeId, std::shared_ptr<RSSurfaceRenderNode>>& GetDirtySurfaceNodeMap()
352     {
353         return dirtySurfaceNodeMap_;
354     }
355 
ClearSurfaceSrcRect()356     void ClearSurfaceSrcRect()
357     {
358         surfaceSrcRects_.clear();
359     }
360 
ClearSurfaceDstRect()361     void ClearSurfaceDstRect()
362     {
363         surfaceDstRects_.clear();
364     }
365 
ClearSurfaceTotalMatrix()366     void ClearSurfaceTotalMatrix()
367     {
368         surfaceTotalMatrix_.clear();
369     }
370 
SetSurfaceSrcRect(NodeId id,RectI rect)371     void SetSurfaceSrcRect(NodeId id, RectI rect)
372     {
373         surfaceSrcRects_[id] = rect;
374     }
375 
SetSurfaceDstRect(NodeId id,RectI rect)376     void SetSurfaceDstRect(NodeId id, RectI rect)
377     {
378         surfaceDstRects_[id] = rect;
379     }
380 
SetSurfaceTotalMatrix(NodeId id,const Drawing::Matrix & totalMatrix)381     void SetSurfaceTotalMatrix(NodeId id, const Drawing::Matrix& totalMatrix)
382     {
383         surfaceTotalMatrix_[id] = totalMatrix;
384     }
385 
GetSurfaceSrcRect(NodeId id)386     RectI GetSurfaceSrcRect(NodeId id) const
387     {
388         auto iter = surfaceSrcRects_.find(id);
389         if (iter == surfaceSrcRects_.cend()) {
390             return RectI();
391         }
392 
393         return iter->second;
394     }
395 
GetSurfaceDstRect(NodeId id)396     RectI GetSurfaceDstRect(NodeId id) const
397     {
398         auto iter = surfaceDstRects_.find(id);
399         if (iter == surfaceDstRects_.cend()) {
400             return {};
401         }
402 
403         return iter->second;
404     }
405 
GetSurfaceTotalMatrix(NodeId id)406     Drawing::Matrix GetSurfaceTotalMatrix(NodeId id) const
407     {
408         auto iter = surfaceTotalMatrix_.find(id);
409         if (iter == surfaceTotalMatrix_.cend()) {
410             return {};
411         }
412 
413         return iter->second;
414     }
415 
416     // Use in MultiLayersPerf
GetSurfaceCountForMultiLayersPerf()417     size_t GetSurfaceCountForMultiLayersPerf() const
418     {
419         return surfaceCountForMultiLayersPerf_;
420     }
421 
422     ChildrenListSharedPtr GetSortedChildren() const override;
423 
424     Occlusion::Region GetDisappearedSurfaceRegionBelowCurrent(NodeId currentSurface) const;
425 
UpdateZoomState(bool state)426     void UpdateZoomState(bool state)
427     {
428         preZoomState_ = curZoomState_;
429         curZoomState_ = state;
430     }
431 
IsZoomStateChange()432     bool IsZoomStateChange() const
433     {
434         return preZoomState_ != curZoomState_;
435     }
436     void HandleCurMainAndLeashSurfaceNodes();
437 
CollectHdrStatus(HdrStatus hdrStatus)438     void CollectHdrStatus(HdrStatus hdrStatus)
439     {
440         displayTotalHdrStatus_ = static_cast<HdrStatus>(displayTotalHdrStatus_ | hdrStatus);
441     }
442 
ResetDisplayHdrStatus()443     void ResetDisplayHdrStatus()
444     {
445         displayTotalHdrStatus_ = HdrStatus::NO_HDR;
446     }
447 
GetDisplayHdrStatus()448     HdrStatus GetDisplayHdrStatus() const
449     {
450         lastDisplayTotalHdrStatus_ = displayTotalHdrStatus_;
451         return displayTotalHdrStatus_;
452     }
453 
GetLastDisplayHDRStatus()454     HdrStatus GetLastDisplayHDRStatus() const
455     {
456         return lastDisplayTotalHdrStatus_;
457     }
458 
InsertHDRNode(NodeId id)459     void InsertHDRNode(NodeId id)
460     {
461         hdrNodeList_.insert(id);
462     }
463 
RemoveHDRNode(NodeId id)464     void RemoveHDRNode(NodeId id)
465     {
466         hdrNodeList_.erase(id);
467     }
468 
GetHDRNodeList()469     std::unordered_set<NodeId>& GetHDRNodeList()
470     {
471         return hdrNodeList_;
472     }
473 
474     // rcd node setter and getter, should be removed in OH 6.0 rcd refactoring
SetRcdSurfaceNodeTop(RSBaseRenderNode::SharedPtr node)475     void SetRcdSurfaceNodeTop(RSBaseRenderNode::SharedPtr node)
476     {
477         rcdSurfaceNodeTop_ = node;
478     }
479 
SetRcdSurfaceNodeBottom(RSBaseRenderNode::SharedPtr node)480     void SetRcdSurfaceNodeBottom(RSBaseRenderNode::SharedPtr node)
481     {
482         rcdSurfaceNodeBottom_ = node;
483     }
484 
GetRcdSurfaceNodeTop()485     RSBaseRenderNode::SharedPtr GetRcdSurfaceNodeTop()
486     {
487         return rcdSurfaceNodeTop_;
488     }
489 
GetRcdSurfaceNodeBottom()490     RSBaseRenderNode::SharedPtr GetRcdSurfaceNodeBottom()
491     {
492         return rcdSurfaceNodeBottom_;
493     }
494 
495     void SetNeedForceUpdateHwcNodes(bool needForceUpdate, bool hasVisibleHwcNodes);
496 
SetTargetSurfaceRenderNodeId(NodeId nodeId)497     void SetTargetSurfaceRenderNodeId(NodeId nodeId)
498     {
499         targetSurfaceRenderNodeId_ = nodeId;
500     }
501 
GetTargetSurfaceRenderNodeId()502     NodeId GetTargetSurfaceRenderNodeId() const
503     {
504         return targetSurfaceRenderNodeId_;
505     }
506 
507     void SetHasMirrorScreen(bool hasMirrorScreen);
508 
509     void SetTargetSurfaceRenderNodeDrawable(DrawableV2::RSRenderNodeDrawableAdapter::WeakPtr drawable);
510 
511     // Enable HWCompose
HwcDisplayRecorder()512     RSHwcDisplayRecorder& HwcDisplayRecorder() { return hwcDisplayRecorder_; }
513 
514     void SetForceFreeze(bool forceFreeze);
515     bool GetForceFreeze() const;
516 
517 protected:
518     void OnSync() override;
519 private:
520     void InitRenderParams() override;
521 
522     bool hasChildCrossNode_ = false;
523     bool isFirstVisitCrossNodeDisplay_ = false;
524     bool forceSoftComposite_ { false };
525     bool isMirroredScreen_ = false;
526     bool hasMirroredScreenChanged_ = false;
527     bool isSecurityDisplay_ = false;
528     bool isForceCloseHdr_ = false;
529     bool isFirstFrameVirtualScreenInit_ = true;
530     bool isFixVirtualBuffer10Bit_ = false;
531     bool existHWCNode_ = false;
532     bool hasUniRenderHdrSurface_ = false;
533     bool isLuminanceStatusChange_ = false;
534     bool hasFingerprint_ = false;
535     bool isGeometryInitialized_ = false;
536 
537     bool forceFreeze_ = false;
538 
539     // Use in vulkan parallel rendering
540     bool isParallelDisplayNode_ = false;
541     mutable bool isNeedWaitNewScbPid_ = false;
542     bool curZoomState_ = false;
543     bool preZoomState_ = false;
544     CompositeType compositeType_ = CompositeType::HARDWARE_COMPOSITE;
545     int32_t currentScbPid_ = -1;
546     int32_t lastScbPid_ = -1;
547     HdrStatus displayTotalHdrStatus_ = HdrStatus::NO_HDR;
548     mutable HdrStatus lastDisplayTotalHdrStatus_ = HdrStatus::NO_HDR;
549     uint64_t screenId_ = 0;
550     RectI screenRect_;
551     // save children hdr canvasNode id
552     std::unordered_set<NodeId> hdrNodeList_;
553     // Use in MultiLayersPerf
554     size_t surfaceCountForMultiLayersPerf_ = 0;
555     int64_t lastRefreshTime_ = 0;
556     static ReleaseDmaBufferTask releaseScreenDmaBufferTask_;
557     std::shared_ptr<RSDirtyRegionManager> dirtyManager_ = nullptr;
558     // Use in screen recording optimization
559     std::shared_ptr<Drawing::Image> offScreenCacheImgForCapture_ = nullptr;
560     WeakPtr mirrorSource_;
561     // vector of sufacenodes will records dirtyregions by itself
562     std::vector<RSBaseRenderNode::SharedPtr> curMainAndLeashSurfaceNodes_;
563     std::vector<DrawableV2::RSRenderNodeDrawableAdapter::SharedPtr> logicalDisplayNodeDrawables_;
564     Drawing::Matrix initMatrix_;
565     GraphicPixelFormat pixelFormat_ = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888;
566     GraphicColorGamut colorSpace_ = GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB;
567 
568     std::map<NodeId, RectI> lastFrameSurfacePos_;
569     std::map<NodeId, RectI> currentFrameSurfacePos_;
570     std::vector<std::pair<NodeId, RectI>> lastFrameSurfacesByDescZOrder_;
571     std::vector<std::pair<NodeId, RectI>> currentFrameSurfacesByDescZOrder_;
572     std::vector<std::string> windowsName_;
573 
574     std::vector<RSBaseRenderNode::SharedPtr> curAllSurfaces_;
575     std::vector<RSBaseRenderNode::SharedPtr> curAllFirstLevelSurfaces_;
576     std::mutex mtx_;
577 
578     std::map<NodeId, std::shared_ptr<RSSurfaceRenderNode>> dirtySurfaceNodeMap_;
579 
580     // support multiscreen
581     std::map<NodeId, RectI> surfaceSrcRects_;
582     std::map<NodeId, RectI> surfaceDstRects_;
583     std::map<NodeId, Drawing::Matrix> surfaceTotalMatrix_;
584 
585     std::vector<NodeId> lastSurfaceIds_;
586 
587     std::vector<int32_t> oldScbPids_ {};
588 
589     bool hasMirrorDisplay_ = false;
590 
591     // Use in round corner display
592     // removed later due to rcd node will be handled by RS tree in OH 6.0 rcd refactoring
593     RSBaseRenderNode::SharedPtr rcdSurfaceNodeTop_ = nullptr;
594     RSBaseRenderNode::SharedPtr rcdSurfaceNodeBottom_ = nullptr;
595 
596     NodeId targetSurfaceRenderNodeId_ = INVALID_NODEID;
597     ScreenInfo screenInfo_;
598     friend class DisplayNodeCommandHelper;
599 
600     // Enable HWCompose
601     RSHwcDisplayRecorder hwcDisplayRecorder_;
602 };
603 } // namespace Rosen
604 } // namespace OHOS
605 
606 #endif // RENDER_SERVICE_CLIENT_CORE_PIPELINE_RS_SCREEN_RENDER_NODE_H
607