1 /*
2  * Copyright (c) 2024 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 
16 #ifndef RENDER_SERVICE_BASE_PARAMS_RS_SURFACE_RENDER_PARAMS_H
17 #define RENDER_SERVICE_BASE_PARAMS_RS_SURFACE_RENDER_PARAMS_H
18 
19 #include <memory>
20 #include <string>
21 
22 #include "common/rs_occlusion_region.h"
23 #include "drawable/rs_render_node_drawable_adapter.h"
24 #include "params/rs_render_params.h"
25 #include "pipeline/rs_base_render_node.h"
26 #ifndef ROSEN_CROSS_PLATFORM
27 #include "surface_buffer.h"
28 #include "sync_fence.h"
29 #endif
30 #include "surface_type.h"
31 
32 namespace OHOS::Rosen {
33 class RSSurfaceRenderNode;
34 struct RSLayerInfo {
35 #ifndef ROSEN_CROSS_PLATFORM
36     GraphicIRect srcRect;
37     GraphicIRect dstRect;
38     GraphicIRect boundRect;
39     Drawing::Matrix matrix;
40     int32_t gravity = 0;
41     int32_t zOrder = 0;
42     float alpha = 1.f;
43     GraphicBlendType blendType;
44     GraphicTransformType transformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
45     int32_t layerSource;
46     bool arsrTag = true;
47 
48     bool operator==(const RSLayerInfo& layerInfo) const
49     {
50         return (srcRect == layerInfo.srcRect) && (dstRect == layerInfo.dstRect) &&
51             (boundRect == layerInfo.boundRect) && (matrix == layerInfo.matrix) && (gravity == layerInfo.gravity) &&
52             (zOrder == layerInfo.zOrder) && (blendType == layerInfo.blendType) &&
53             (transformType == layerInfo.transformType) && (ROSEN_EQ(alpha, layerInfo.alpha)) &&
54             (layerSource == layerInfo.layerSource)  && (arsrTag == layerInfo.arsrTag);
55     }
56 #endif
57 };
58 struct RSWindowInfo {
59     bool isMainWindowType_ = false;
60     bool isLeashWindow_ = false;
61     bool isAppWindow_ = false;
SetWindowInfoRSWindowInfo62     void SetWindowInfo(bool isMainWindowType, bool isLeashWindow, bool isAppWindow)
63     {
64         isMainWindowType_ = isMainWindowType;
65         isLeashWindow_ = isLeashWindow;
66         isAppWindow_ = isAppWindow;
67     }
68 };
69 class RSB_EXPORT RSSurfaceRenderParams : public RSRenderParams {
70 public:
71     explicit RSSurfaceRenderParams(NodeId id);
72     ~RSSurfaceRenderParams() override = default;
IsMainWindowType()73     inline bool IsMainWindowType() const
74     {
75         return windowInfo_.isMainWindowType_;
76     }
IsLeashWindow()77     inline bool IsLeashWindow() const override
78     {
79         return windowInfo_.isLeashWindow_;
80     }
IsAppWindow()81     bool IsAppWindow() const override
82     {
83         return windowInfo_.isAppWindow_;
84     }
SetWindowInfo(bool isMainWindowType,bool isLeashWindow,bool isAppWindow)85     void SetWindowInfo(bool isMainWindowType, bool isLeashWindow, bool isAppWindow)
86     {
87         windowInfo_.SetWindowInfo(isMainWindowType, isLeashWindow, isAppWindow);
88     }
GetSurfaceNodeType()89     RSSurfaceNodeType GetSurfaceNodeType() const
90     {
91         return rsSurfaceNodeType_;
92     }
GetSelfDrawingNodeType()93     SelfDrawingNodeType GetSelfDrawingNodeType() const
94     {
95         return selfDrawingType_;
96     }
SetAncestorDisplayNode(const RSRenderNode::WeakPtr & ancestorDisplayNode)97     void SetAncestorDisplayNode(const RSRenderNode::WeakPtr& ancestorDisplayNode)
98     {
99         ancestorDisplayNode_ = ancestorDisplayNode;
100         auto node = ancestorDisplayNode.lock();
101         ancestorDisplayDrawable_ = node ? node->GetRenderDrawable() : nullptr;
102     }
103 
GetAncestorDisplayNode()104     RSRenderNode::WeakPtr GetAncestorDisplayNode() const
105     {
106         return ancestorDisplayNode_;
107     }
GetAncestorDisplayDrawable()108     DrawableV2::RSRenderNodeDrawableAdapter::WeakPtr GetAncestorDisplayDrawable() const
109     {
110         return ancestorDisplayDrawable_;
111     }
112 
GetAlpha()113     float GetAlpha() const
114     {
115         return alpha_;
116     }
IsSpherizeValid()117     bool IsSpherizeValid() const
118     {
119         return isSpherizeValid_;
120     }
IsAttractionValid()121     bool IsAttractionValid() const
122     {
123         return isAttractionValid_;
124     }
NeedBilinearInterpolation()125     bool NeedBilinearInterpolation() const
126     {
127         return needBilinearInterpolation_;
128     }
GetBackgroundColor()129     const Color& GetBackgroundColor() const
130     {
131         return backgroundColor_;
132     }
GetAbsDrawRect()133     const RectI& GetAbsDrawRect() const override
134     {
135         return absDrawRect_;
136     }
GetRRect()137     const RRect& GetRRect() const
138     {
139         return rrect_;
140     }
141 
GetIsSecurityLayer()142     bool GetIsSecurityLayer() const
143     {
144         return isSecurityLayer_;
145     }
GetIsSkipLayer()146     bool GetIsSkipLayer() const
147     {
148         return isSkipLayer_;
149     }
GetIsProtectedLayer()150     bool GetIsProtectedLayer() const
151     {
152         return isProtectedLayer_;
153     }
GetAnimateState()154     bool GetAnimateState() const
155     {
156         return animateState_;
157     }
GetSecurityLayerIds()158     const std::set<NodeId>& GetSecurityLayerIds() const
159     {
160         return securityLayerIds_;
161     }
GetSkipLayerIds()162     const std::set<NodeId>& GetSkipLayerIds() const
163     {
164         return skipLayerIds_;
165     }
HasSecurityLayer()166     bool HasSecurityLayer()
167     {
168         return securityLayerIds_.size() != 0;
169     }
HasSkipLayer()170     bool HasSkipLayer()
171     {
172         return skipLayerIds_.size() != 0;
173     }
HasProtectedLayer()174     bool HasProtectedLayer()
175     {
176         return protectedLayerIds_.size() != 0;
177     }
HasPrivacyContentLayer()178     bool HasPrivacyContentLayer()
179     {
180         return privacyContentLayerIds_.size() != 0;
181     }
182 
GetLeashPersistentId()183     LeashPersistentId GetLeashPersistentId() const
184     {
185         return leashPersistentId_;
186     }
187 
GetName()188     std::string GetName() const
189     {
190         return name_;
191     }
192 
SetLeashWindowVisibleRegionEmptyParam(bool isLeashWindowVisibleRegionEmpty)193     void SetLeashWindowVisibleRegionEmptyParam(bool isLeashWindowVisibleRegionEmpty)
194     {
195         if (isLeashWindowVisibleRegionEmpty_ == isLeashWindowVisibleRegionEmpty) {
196             return;
197         }
198         isLeashWindowVisibleRegionEmpty_ = isLeashWindowVisibleRegionEmpty;
199         needSync_ = true;
200     }
201 
GetLeashWindowVisibleRegionEmptyParam()202     bool GetLeashWindowVisibleRegionEmptyParam() const
203     {
204         return isLeashWindowVisibleRegionEmpty_;
205     }
206 
SetUifirstNodeEnableParam(MultiThreadCacheType isUifirst)207     void SetUifirstNodeEnableParam(MultiThreadCacheType isUifirst)
208     {
209         if (uiFirstFlag_ == isUifirst) {
210             return;
211         }
212         uiFirstFlag_ = isUifirst;
213         needSync_ = true;
214     }
215 
GetUifirstNodeEnableParam()216     MultiThreadCacheType GetUifirstNodeEnableParam() const
217     {
218         return uiFirstFlag_;
219     }
220 
SetBufferClearCacheSet(const std::set<int32_t> bufferCacheSet)221     void SetBufferClearCacheSet(const std::set<int32_t> bufferCacheSet)
222     {
223         if (bufferCacheSet.size() > 0) {
224             bufferCacheSet_ = bufferCacheSet;
225             needSync_ = true;
226         }
227     }
228 
GetBufferClearCacheSet()229     const std::set<int32_t> GetBufferClearCacheSet()
230     {
231         return bufferCacheSet_;
232     }
233 
SetIsParentUifirstNodeEnableParam(bool isUifirstParent)234     void SetIsParentUifirstNodeEnableParam(bool isUifirstParent)
235     {
236         if (uiFirstParentFlag_ == isUifirstParent) {
237             return;
238         }
239         uiFirstParentFlag_ = isUifirstParent;
240         needSync_ = true;
241     }
242 
SetUifirstUseStarting(NodeId id)243     void SetUifirstUseStarting(NodeId id)
244     {
245         if (uifirstUseStarting_ == id) {
246             return;
247         }
248         uifirstUseStarting_ = id;
249         needSync_ = true;
250     }
251 
GetUifirstUseStarting()252     NodeId GetUifirstUseStarting() const
253     {
254         return uifirstUseStarting_;
255     }
256 
SetUifirstChildrenDirtyRectParam(const RectI & rect)257     void SetUifirstChildrenDirtyRectParam(const RectI& rect)
258     {
259         childrenDirtyRect_ = rect;
260         needSync_ = true;
261     }
262 
GetUifirstChildrenDirtyRectParam()263     RectI& GetUifirstChildrenDirtyRectParam()
264     {
265         return childrenDirtyRect_;
266     }
GetDstRect()267     const RectI& GetDstRect() const
268     {
269         return dstRect_;
270     }
271     void SetSurfaceCacheContentStatic(bool contentStatic, bool lastFrameSynced);
272     bool GetSurfaceCacheContentStatic() const;
273     bool GetPreSurfaceCacheContentStatic() const;
274 
275     float GetPositionZ() const;
276 
277     void SetSurfaceSubTreeDirty(bool isSubTreeDirty);
278     bool GetSurfaceSubTreeDirty() const;
279 
GetParentUifirstNodeEnableParam()280     bool GetParentUifirstNodeEnableParam()
281     {
282         return uiFirstParentFlag_;
283     }
284 
SetUIFirstFrameGravity(Gravity gravity)285     void SetUIFirstFrameGravity(Gravity gravity)
286     {
287         if (uiFirstFrameGravity_ == gravity) {
288             return;
289         }
290         uiFirstFrameGravity_ = gravity;
291         needSync_ = true;
292     }
293 
GetUIFirstFrameGravity()294     Gravity GetUIFirstFrameGravity() const
295     {
296         return uiFirstFrameGravity_;
297     }
298 
299     void SetOcclusionVisible(bool visible);
300     bool GetOcclusionVisible() const override;
301 
302     void SetIsParentScaling(bool isParentScaling);
303     bool IsParentScaling() const;
304 
305     void SetTransparentRegion(const Occlusion::Region& transparentRegion);
306     const Occlusion::Region& GetTransparentRegion() const;
307 
308     void SetOldDirtyInSurface(const RectI& oldDirtyInSurface) override;
309     RectI GetOldDirtyInSurface() const override;
310 
311     void SetVisibleRegion(const Occlusion::Region& visibleRegion);
312     Occlusion::Region GetVisibleRegion() const override;
313 
314     void SetVisibleRegionInVirtual(const Occlusion::Region& visibleRegion);
315     Occlusion::Region GetVisibleRegionInVirtual() const;
316 
317     void SetOccludedByFilterCache(bool val);
318     bool GetOccludedByFilterCache() const;
319 
320     void SetFilterCacheFullyCovered(bool val);
321     bool GetFilterCacheFullyCovered() const;
322 
323     const std::vector<NodeId>& GetVisibleFilterChild() const;
324     bool IsTransparent() const;
325     void CheckValidFilterCacheFullyCoverTarget(
326         bool isFilterCacheValidForOcclusion, const RectI& filterCachedRect, const RectI& targetRect);
327 
328     void SetLayerInfo(const RSLayerInfo& layerInfo);
329     const RSLayerInfo& GetLayerInfo() const override;
330     void SetHardwareEnabled(bool enabled);
331     bool GetHardwareEnabled() const override;
332     void SetHardCursorStatus(bool status);
333     bool GetHardCursorStatus() const override;
334     void SetLastFrameHardwareEnabled(bool enabled);
335     bool GetLastFrameHardwareEnabled() const override;
336     void SetFixRotationByUser(bool flag);
337     bool GetFixRotationByUser() const;
338     void SetInFixedRotation(bool flag);
339     bool IsInFixedRotation() const;
340     // source crop tuning
341     void SetLayerSourceTuning(int32_t needSourceTuning);
342     int32_t GetLayerSourceTuning() const;
343 
344     void SetGpuOverDrawBufferOptimizeNode(bool overDrawNode);
345     bool IsGpuOverDrawBufferOptimizeNode() const;
346     void SetOverDrawBufferNodeCornerRadius(const Vector4f& radius);
347     const Vector4f& GetOverDrawBufferNodeCornerRadius() const;
348 
349     void SetIsSubSurfaceNode(bool isSubSurfaceNode);
350     bool IsSubSurfaceNode() const;
351 
352     void SetIsNodeToBeCaptured(bool isNodeToBeCaptured);
353     bool IsNodeToBeCaptured() const;
354 
355     void SetSkipDraw(bool skip);
356     bool GetSkipDraw() const;
357 
358     void SetHidePrivacyContent(bool needHidePrivacyContent);
359     bool GetHidePrivacyContent() const;
360 
361     void SetLayerTop(bool isTop);
362     bool IsLayerTop() const;
363 
364     bool IsVisibleDirtyRegionEmpty(const Drawing::Region curSurfaceDrawRegion) const;
365 
366 #ifndef ROSEN_CROSS_PLATFORM
367     void SetBuffer(const sptr<SurfaceBuffer>& buffer, const Rect& damageRect) override;
368     sptr<SurfaceBuffer> GetBuffer() const override;
369     void SetPreBuffer(const sptr<SurfaceBuffer>& preBuffer) override;
370     sptr<SurfaceBuffer> GetPreBuffer() override;
371     void SetAcquireFence(const sptr<SyncFence>& acquireFence) override;
372     sptr<SyncFence> GetAcquireFence() const override;
373     const Rect& GetBufferDamage() const override;
SetBufferSynced(bool bufferSynced)374     inline void SetBufferSynced(bool bufferSynced)
375     {
376         bufferSynced_ = bufferSynced;
377     }
IsBufferSynced()378     bool IsBufferSynced() const
379     {
380         return bufferSynced_;
381     }
382 #endif
383 
384     virtual void OnSync(const std::unique_ptr<RSRenderParams>& target) override;
385 
386     // DFX
387     std::string ToString() const override;
388     // Set/Get OpaqueRegion, currently only used for DFX
389     void SetOpaqueRegion(const Occlusion::Region& opaqueRegion);
390     const Occlusion::Region& GetOpaqueRegion() const;
391 
SetNeedOffscreen(bool needOffscreen)392     void SetNeedOffscreen(bool needOffscreen)
393     {
394         if (needOffscreen_ == needOffscreen) {
395             return;
396         }
397         needOffscreen_ = needOffscreen;
398         needSync_ = true;
399     }
400 
GetNeedOffscreen()401     bool GetNeedOffscreen() const
402     {
403         return RSSystemProperties::GetSurfaceOffscreenEnadbled() ? needOffscreen_ : false;
404     }
405 
SetLayerCreated(bool layerCreated)406     void SetLayerCreated(bool layerCreated) override
407     {
408         layerCreated_ = layerCreated;
409     }
410 
GetLayerCreated()411     bool GetLayerCreated() const override
412     {
413         return layerCreated_;
414     }
SetTotalMatrix(const Drawing::Matrix & totalMatrix)415     void SetTotalMatrix(const Drawing::Matrix& totalMatrix) override
416     {
417         if (totalMatrix_ == totalMatrix) {
418             return;
419         }
420         totalMatrix_ = totalMatrix;
421         needSync_ = true;
422     }
GetTotalMatrix()423     const Drawing::Matrix& GetTotalMatrix() override
424     {
425         return totalMatrix_;
426     }
SetFingerprint(bool hasFingerprint)427     void SetFingerprint(bool hasFingerprint) override
428     {
429         if (hasFingerprint_ == hasFingerprint) {
430             return;
431         }
432         hasFingerprint_ = hasFingerprint;
433         needSync_ = true;
434     }
GetFingerprint()435     bool GetFingerprint() override {
436         return false;
437     }
438 
SetCornerRadiusInfoForDRM(const std::vector<float> & drmCornerRadiusInfo)439     void SetCornerRadiusInfoForDRM(const std::vector<float>& drmCornerRadiusInfo)
440     {
441         if (drmCornerRadiusInfo_ == drmCornerRadiusInfo) {
442             return;
443         }
444         drmCornerRadiusInfo_ = drmCornerRadiusInfo;
445         needSync_ = true;
446     }
447 
GetCornerRadiusInfoForDRM()448     const std::vector<float>& GetCornerRadiusInfoForDRM() const
449     {
450         return drmCornerRadiusInfo_;
451     }
452 
SetSdrNit(float sdrNit)453     void SetSdrNit(float sdrNit)
454     {
455         if (ROSEN_EQ(sdrNit_, sdrNit)) {
456             return;
457         }
458         sdrNit_ = sdrNit;
459         needSync_ = true;
460     }
461 
GetSdrNit()462     float GetSdrNit() const
463     {
464         return sdrNit_;
465     }
466 
SetDisplayNit(float displayNit)467     void SetDisplayNit(float displayNit)
468     {
469         if (ROSEN_EQ(displayNit_, displayNit)) {
470             return;
471         }
472         displayNit_ = displayNit;
473         needSync_ = true;
474     }
475 
GetDisplayNit()476     float GetDisplayNit() const
477     {
478         return displayNit_;
479     }
480 
SetBrightnessRatio(float brightnessRatio)481     void SetBrightnessRatio(float brightnessRatio)
482     {
483         if (ROSEN_EQ(brightnessRatio_, brightnessRatio)) {
484             return;
485         }
486         brightnessRatio_ = brightnessRatio;
487         needSync_ = true;
488     }
489 
GetBrightnessRatio()490     float GetBrightnessRatio() const
491     {
492         return brightnessRatio_;
493     }
494 
HasSubSurfaceNodes()495     inline bool HasSubSurfaceNodes() const
496     {
497         return hasSubSurfaceNodes_;
498     }
GetAllSubSurfaceNodeIds()499     const std::unordered_set<NodeId>& GetAllSubSurfaceNodeIds() const
500     {
501         return allSubSurfaceNodeIds_;
502     }
GetIsHwcEnabledBySolidLayer()503     bool GetIsHwcEnabledBySolidLayer()
504     {
505         return isHwcEnabledBySolidLayer_;
506     }
507 
SetIsHwcEnabledBySolidLayer(bool isHwcEnabledBySolidLayer)508     void SetIsHwcEnabledBySolidLayer(bool isHwcEnabledBySolidLayer)
509     {
510         isHwcEnabledBySolidLayer_ = isHwcEnabledBySolidLayer;
511     }
512 
SetApiCompatibleVersion(uint32_t apiCompatibleVersion)513     void SetApiCompatibleVersion(uint32_t apiCompatibleVersion)
514     {
515         if (ROSEN_EQ(apiCompatibleVersion_, apiCompatibleVersion)) {
516             return;
517         }
518         apiCompatibleVersion_ = apiCompatibleVersion;
519         needSync_ = true;
520     }
GetApiCompatibleVersion()521     uint32_t GetApiCompatibleVersion() const
522     {
523         return apiCompatibleVersion_;
524     }
525 
526 protected:
527 private:
528     RSSurfaceNodeType rsSurfaceNodeType_ = RSSurfaceNodeType::DEFAULT;
529     SelfDrawingNodeType selfDrawingType_ = SelfDrawingNodeType::DEFAULT;
530     RSRenderNode::WeakPtr ancestorDisplayNode_;
531     DrawableV2::RSRenderNodeDrawableAdapter::WeakPtr ancestorDisplayDrawable_;
532 
533     float alpha_ = 0;
534     bool isTransparent_ = false;
535     bool isSpherizeValid_ = false;
536     bool isAttractionValid_ = false;
537     bool isParentScaling_ = false;
538     bool needBilinearInterpolation_ = false;
539     MultiThreadCacheType uiFirstFlag_ = MultiThreadCacheType::NONE;
540     bool uiFirstParentFlag_ = false;
541     NodeId uifirstUseStarting_ = INVALID_NODEID;
542     Color backgroundColor_ = RgbPalette::Transparent();
543     bool isHwcEnabledBySolidLayer_ = false;
544 
545     RectI dstRect_;
546     RectI oldDirtyInSurface_;
547     RectI childrenDirtyRect_;
548     RectI absDrawRect_;
549     RRect rrect_;
550     Occlusion::Region transparentRegion_;
551     Occlusion::Region opaqueRegion_;
552 
553     LeashPersistentId leashPersistentId_ = INVALID_LEASH_PERSISTENTID;
554 
555     bool surfaceCacheContentStatic_ = false;
556     bool preSurfaceCacheContentStatic_ = false;
557     bool isSubTreeDirty_ = false;
558     float positionZ_ = 0.0f;
559     bool occlusionVisible_ = false;
560     bool isLeashWindowVisibleRegionEmpty_ = false;
561     Occlusion::Region visibleRegion_;
562     Occlusion::Region visibleRegionInVirtual_;
563     bool isOccludedByFilterCache_ = false;
564     // if current surfaceNode has filter cache to occlude the back surfaceNode
565     bool isFilterCacheFullyCovered_ = false;
566     std::vector<NodeId> visibleFilterChild_;
567     RSLayerInfo layerInfo_;
568     RSWindowInfo windowInfo_;
569 #ifndef ROSEN_CROSS_PLATFORM
570     sptr<SurfaceBuffer> buffer_ = nullptr;
571     sptr<SurfaceBuffer> preBuffer_ = nullptr;
572     sptr<SyncFence> acquireFence_ = SyncFence::InvalidFence();
573     Rect damageRect_ = {0, 0, 0, 0};
574     bool bufferSynced_ = true;
575 #endif
576     bool isHardwareEnabled_ = false;
577     bool isHardCursor_ = false;
578     bool isLastFrameHardwareEnabled_ = false;
579     bool isFixRotationByUser_ = false;
580     bool isInFixedRotation_ = false;
581     int32_t releaseInHardwareThreadTaskNum_ = 0;
582     bool isSecurityLayer_ = false;
583     bool isSkipLayer_ = false;
584     bool isProtectedLayer_ = false;
585     bool animateState_ = false;
586     bool isSubSurfaceNode_ = false;
587     Gravity uiFirstFrameGravity_ = Gravity::TOP_LEFT;
588     bool isNodeToBeCaptured_ = false;
589     std::set<NodeId> skipLayerIds_= {};
590     std::set<NodeId> securityLayerIds_= {};
591     std::set<NodeId> protectedLayerIds_= {};
592     std::set<NodeId> privacyContentLayerIds_ = {};
593     std::set<int32_t> bufferCacheSet_ = {};
594     std::string name_= "";
595     Vector4f overDrawBufferNodeCornerRadius_;
596     bool isGpuOverDrawBufferOptimizeNode_ = false;
597     bool isSkipDraw_ = false;
598     bool isLayerTop_ = false;
599     bool needHidePrivacyContent_ = false;
600     bool needOffscreen_ = false;
601     bool layerCreated_ = false;
602     int32_t layerSource_ = 0;
603     std::vector<float> drmCornerRadiusInfo_;
604 
605     Drawing::Matrix totalMatrix_;
606     float globalAlpha_ = 1.0f;
607     bool hasFingerprint_ = false;
608     // hdr
609     float sdrNit_ = 500.0f; // default sdrNit
610     float displayNit_ = 500.0f; // default displayNit_
611     float brightnessRatio_ = 1.0f; // 1.0f means no discount.
612 
613     bool hasSubSurfaceNodes_ = false;
614     std::unordered_set<NodeId> allSubSurfaceNodeIds_ = {};
615 
616     uint32_t apiCompatibleVersion_ = 0;
617 
618     friend class RSSurfaceRenderNode;
619     friend class RSUniRenderProcessor;
620     friend class RSUniRenderThread;
621 };
622 } // namespace OHOS::Rosen
623 #endif // RENDER_SERVICE_BASE_PARAMS_RS_SURFACE_RENDER_PARAMS_H
624