1 /*
2  * Copyright (c) 2021-2022 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 #include "rs_uni_render_processor.h"
17 
18 #include <vector>
19 
20 #include "hdi_layer.h"
21 #include "hdi_layer_info.h"
22 #include "luminance/rs_luminance_control.h"
23 #include "rs_trace.h"
24 #include "rs_uni_render_util.h"
25 #include "string_utils.h"
26 #include "surface_type.h"
27 
28 #include "common/rs_optional_trace.h"
29 #include "drawable/rs_display_render_node_drawable.h"
30 #include "drawable/rs_surface_render_node_drawable.h"
31 #include "params/rs_display_render_params.h"
32 #include "params/rs_surface_render_params.h"
33 #include "pipeline/parallel_render/rs_sub_thread_manager.h"
34 #include "pipeline/round_corner_display/rs_rcd_surface_render_node.h"
35 #include "platform/common/rs_log.h"
36 #ifdef USE_VIDEO_PROCESSING_ENGINE
37 #include "metadata_helper.h"
38 #endif
39 namespace OHOS {
40 namespace Rosen {
RSUniRenderProcessor()41 RSUniRenderProcessor::RSUniRenderProcessor()
42     : uniComposerAdapter_(std::make_unique<RSUniRenderComposerAdapter>())
43 {
44 }
45 
~RSUniRenderProcessor()46 RSUniRenderProcessor::~RSUniRenderProcessor() noexcept
47 {
48 }
49 
Init(RSDisplayRenderNode & node,int32_t offsetX,int32_t offsetY,ScreenId mirroredId,std::shared_ptr<RSBaseRenderEngine> renderEngine)50 bool RSUniRenderProcessor::Init(RSDisplayRenderNode& node, int32_t offsetX, int32_t offsetY, ScreenId mirroredId,
51                                 std::shared_ptr<RSBaseRenderEngine> renderEngine)
52 {
53     if (!RSProcessor::Init(node, offsetX, offsetY, mirroredId, renderEngine)) {
54         return false;
55     }
56     // In uni render mode, we can handle screen rotation in the rendering process,
57     // so we do not need to handle rotation in composer adapter any more,
58     // just pass the buffer to composer straightly.
59     screenInfo_.rotation = ScreenRotation::ROTATION_0;
60     isPhone_ = RSMainThread::Instance()->GetDeviceType() == DeviceType::PHONE;
61     return uniComposerAdapter_->Init(screenInfo_, offsetX_, offsetY_, mirrorAdaptiveCoefficient_);
62 }
63 
InitForRenderThread(DrawableV2::RSDisplayRenderNodeDrawable & displayDrawable,ScreenId mirroredId,std::shared_ptr<RSBaseRenderEngine> renderEngine)64 bool RSUniRenderProcessor::InitForRenderThread(DrawableV2::RSDisplayRenderNodeDrawable& displayDrawable,
65     ScreenId mirroredId, std::shared_ptr<RSBaseRenderEngine> renderEngine)
66 {
67     if (!RSProcessor::InitForRenderThread(displayDrawable, mirroredId, renderEngine)) {
68         return false;
69     }
70     // In uni render mode, we can handle screen rotation in the rendering process,
71     // so we do not need to handle rotation in composer adapter any more,
72     // just pass the buffer to composer straightly.
73     screenInfo_.rotation = ScreenRotation::ROTATION_0;
74     isPhone_ = RSMainThread::Instance()->GetDeviceType() == DeviceType::PHONE;
75     return uniComposerAdapter_->Init(screenInfo_, offsetX_, offsetY_, mirrorAdaptiveCoefficient_);
76 }
77 
PostProcess()78 void RSUniRenderProcessor::PostProcess()
79 {
80     uniComposerAdapter_->CommitLayers(layers_);
81     if (!isPhone_) {
82         MultiLayersPerf(layerNum_);
83     }
84     RS_LOGD("RSUniRenderProcessor::PostProcess layers_:%{public}zu", layers_.size());
85 }
86 
CreateLayer(RSSurfaceRenderNode & node,RSSurfaceRenderParams & params)87 void RSUniRenderProcessor::CreateLayer(RSSurfaceRenderNode& node, RSSurfaceRenderParams& params)
88 {
89     auto surfaceHandler = node.GetRSSurfaceHandler();
90     auto buffer = surfaceHandler->GetBuffer();
91     if (buffer == nullptr || surfaceHandler->GetConsumer() == nullptr) {
92         return;
93     }
94     auto& layerInfo = params.GetLayerInfo();
95     const Rect& dirtyRect = params.GetBufferDamage();
96     RS_OPTIONAL_TRACE_NAME_FMT(
97         "CreateLayer name:%s zorder:%d src:[%d, %d, %d, %d] dst:[%d, %d, %d, %d] dirty:[%d, %d, %d, %d] "
98         "buffer:[%d, %d] alpha:[%f] ",
99         node.GetName().c_str(), layerInfo.zOrder,
100         layerInfo.srcRect.x, layerInfo.srcRect.y, layerInfo.srcRect.w, layerInfo.srcRect.h,
101         layerInfo.dstRect.x, layerInfo.dstRect.y, layerInfo.dstRect.w, layerInfo.dstRect.h,
102         dirtyRect.x, dirtyRect.y, dirtyRect.w, dirtyRect.h,
103         buffer->GetSurfaceBufferWidth(), buffer->GetSurfaceBufferHeight(), layerInfo.alpha);
104     RS_LOGD("CreateLayer name:%{public}s zorder:%{public}d src:[%{public}d, %{public}d, %{public}d, %{public}d] "
105             "dst:[%{public}d, %{public}d, %{public}d, %{public}d] "
106             "drity:[%{public}d, %{public}d, %{public}d, %{public}d] "
107             "buffer:[%{public}d, %{public}d] alpha:[%{public}f]",
108         node.GetName().c_str(), layerInfo.zOrder,
109         layerInfo.srcRect.x, layerInfo.srcRect.y, layerInfo.srcRect.w, layerInfo.srcRect.h,
110         layerInfo.dstRect.x, layerInfo.dstRect.y, layerInfo.dstRect.w, layerInfo.dstRect.h,
111         dirtyRect.x, dirtyRect.y, dirtyRect.w, dirtyRect.h,
112         buffer->GetSurfaceBufferWidth(), buffer->GetSurfaceBufferHeight(), layerInfo.alpha);
113     auto preBuffer = params.GetPreBuffer();
114     LayerInfoPtr layer = GetLayerInfo(
115         params, buffer, preBuffer, surfaceHandler->GetConsumer(), params.GetAcquireFence());
116     layer->SetSdrNit(params.GetSdrNit());
117     layer->SetDisplayNit(params.GetDisplayNit());
118     layer->SetBrightnessRatio(params.GetBrightnessRatio());
119 
120     uniComposerAdapter_->SetMetaDataInfoToLayer(layer, params.GetBuffer(), surfaceHandler->GetConsumer());
121     CreateSolidColorLayer(layer, params);
122     layers_.emplace_back(layer);
123     params.SetLayerCreated(true);
124 }
125 
CreateLayerForRenderThread(DrawableV2::RSSurfaceRenderNodeDrawable & surfaceDrawable)126 void RSUniRenderProcessor::CreateLayerForRenderThread(DrawableV2::RSSurfaceRenderNodeDrawable& surfaceDrawable)
127 {
128     auto& paramsSp = surfaceDrawable.GetRenderParams();
129     if (!paramsSp) {
130         return;
131     }
132     auto& params = *(static_cast<RSSurfaceRenderParams*>(paramsSp.get()));
133     auto buffer = params.GetBuffer();
134     if (buffer == nullptr) {
135         return;
136     }
137     auto& layerInfo = params.GetLayerInfo();
138     const Rect& dirtyRect = params.GetBufferDamage();
139     RS_OPTIONAL_TRACE_NAME_FMT(
140         "CreateLayer name:%s zorder:%d src:[%d, %d, %d, %d] dst:[%d, %d, %d, %d] dirty:[%d, %d, %d, %d] "
141         "buffer:[%d, %d] alpha:[%f] ",
142         surfaceDrawable.GetName().c_str(), layerInfo.zOrder,
143         layerInfo.srcRect.x, layerInfo.srcRect.y, layerInfo.srcRect.w, layerInfo.srcRect.h,
144         layerInfo.dstRect.x, layerInfo.dstRect.y, layerInfo.dstRect.w, layerInfo.dstRect.h,
145         dirtyRect.x, dirtyRect.y, dirtyRect.w, dirtyRect.h,
146         buffer->GetSurfaceBufferWidth(), buffer->GetSurfaceBufferHeight(), layerInfo.alpha);
147     RS_LOGD("CreateLayer name:%{public}s zorder:%{public}d src:[%{public}d, %{public}d, %{public}d, %{public}d] "
148             "dst:[%{public}d, %{public}d, %{public}d, %{public}d] "
149             "drity:[%{public}d, %{public}d, %{public}d, %{public}d] "
150             "buffer:[%{public}d, %{public}d] alpha:[%{public}f]",
151         surfaceDrawable.GetName().c_str(), layerInfo.zOrder,
152         layerInfo.srcRect.x, layerInfo.srcRect.y, layerInfo.srcRect.w, layerInfo.srcRect.h,
153         layerInfo.dstRect.x, layerInfo.dstRect.y, layerInfo.dstRect.w, layerInfo.dstRect.h,
154         dirtyRect.x, dirtyRect.y, dirtyRect.w, dirtyRect.h,
155         buffer->GetSurfaceBufferWidth(), buffer->GetSurfaceBufferHeight(), layerInfo.alpha);
156     auto preBuffer = params.GetPreBuffer();
157     LayerInfoPtr layer = GetLayerInfo(static_cast<RSSurfaceRenderParams&>(params), buffer, preBuffer,
158         surfaceDrawable.GetConsumerOnDraw(), params.GetAcquireFence());
159     layer->SetNodeId(surfaceDrawable.GetId());
160     auto& renderParams = static_cast<RSSurfaceRenderParams&>(params);
161     layer->SetSdrNit(renderParams.GetSdrNit());
162     layer->SetDisplayNit(renderParams.GetDisplayNit());
163     layer->SetBrightnessRatio(renderParams.GetBrightnessRatio());
164     uniComposerAdapter_->SetMetaDataInfoToLayer(layer, params.GetBuffer(), surfaceDrawable.GetConsumerOnDraw());
165     CreateSolidColorLayer(layer, params);
166     layers_.emplace_back(layer);
167     params.SetLayerCreated(true);
168 }
169 
CreateUIFirstLayer(DrawableV2::RSSurfaceRenderNodeDrawable & drawable,RSSurfaceRenderParams & params)170 void RSUniRenderProcessor::CreateUIFirstLayer(DrawableV2::RSSurfaceRenderNodeDrawable& drawable,
171     RSSurfaceRenderParams& params)
172 {
173     auto surfaceHandler = drawable.GetMutableRSSurfaceHandlerUiFirstOnDraw();
174     if (!surfaceHandler) {
175         return;
176     }
177     auto buffer = surfaceHandler->GetBuffer();
178     if (buffer == nullptr && surfaceHandler->GetAvailableBufferCount() <= 0) {
179         RS_TRACE_NAME_FMT("HandleSubThreadNode wait %" PRIu64 "", params.GetId());
180         RSSubThreadManager::Instance()->WaitNodeTask(params.GetId());
181     }
182     if (!RSBaseRenderUtil::ConsumeAndUpdateBuffer(*surfaceHandler) || !surfaceHandler->GetBuffer()) {
183         RS_LOGE("CreateUIFirstLayer ConsumeAndUpdateBuffer or GetBuffer return  false");
184         return;
185     }
186     buffer = surfaceHandler->GetBuffer();
187     auto preBuffer = surfaceHandler->GetPreBuffer();
188     LayerInfoPtr layer = GetLayerInfo(
189         params, buffer, preBuffer, surfaceHandler->GetConsumer(), surfaceHandler->GetAcquireFence());
190     uniComposerAdapter_->SetMetaDataInfoToLayer(layer, params.GetBuffer(), surfaceHandler->GetConsumer());
191     layers_.emplace_back(layer);
192     auto& layerInfo = params.layerInfo_;
193     RS_LOGD("RSUniRenderProcessor::CreateUIFirstLayer: [%{public}s-%{public}" PRIu64 "] "
194         "src: %{public}d %{public}d %{public}d %{public}d, "
195         "dst: %{public}d %{public}d %{public}d %{public}d, zOrder: %{public}d",
196         drawable.GetName().c_str(), drawable.GetId(),
197         layerInfo.srcRect.x, layerInfo.srcRect.y, layerInfo.srcRect.w, layerInfo.srcRect.h,
198         layerInfo.dstRect.x, layerInfo.dstRect.y, layerInfo.dstRect.w, layerInfo.dstRect.h, layerInfo.zOrder);
199 }
200 
CreateSolidColorLayer(LayerInfoPtr layer,RSSurfaceRenderParams & params)201 void RSUniRenderProcessor::CreateSolidColorLayer(LayerInfoPtr layer, RSSurfaceRenderParams& params)
202 {
203     auto color = params.GetBackgroundColor();
204     if (!params.GetIsHwcEnabledBySolidLayer()) {
205         return;
206     }
207     auto solidColorLayer = HdiLayerInfo::CreateHdiLayerInfo();
208     solidColorLayer->CopyLayerInfo(layer);
209     if (layer->GetZorder() > 0) {
210         solidColorLayer->SetZorder(layer->GetZorder() - 1);
211     }
212     auto dstRect = params.layerInfo_.dstRect;
213     GraphicIRect layerRect = {dstRect.x, dstRect.y, dstRect.w, dstRect.h};
214     solidColorLayer->SetLayerSize(layerRect);
215     solidColorLayer->SetCompositionType(GraphicCompositionType::GRAPHIC_COMPOSITION_SOLID_COLOR);
216     solidColorLayer->SetLayerColor({color.GetRed(), color.GetGreen(), color.GetBlue(), color.GetAlpha()});
217     solidColorLayer->SetSurface({});
218     solidColorLayer->SetBuffer({}, {});
219     solidColorLayer->SetPreBuffer({});
220     solidColorLayer->SetMetaData({});
221     layers_.emplace_back(solidColorLayer);
222 }
223 
GetForceClientForDRM(RSSurfaceRenderParams & params)224 bool RSUniRenderProcessor::GetForceClientForDRM(RSSurfaceRenderParams& params)
225 {
226     if (params.GetIsProtectedLayer() == false) {
227         return false;
228     }
229     if (params.GetAnimateState() == true ||
230         RSUniRenderUtil::GetRotationDegreeFromMatrix(params.GetTotalMatrix()) % RS_ROTATION_90 != 0) {
231         return true;
232     }
233     if (!params.GetCornerRadiusInfoForDRM().empty()) {
234         return true;
235     }
236     bool forceClientForDRM = false;
237     auto ancestorDisplayDrawable =
238         std::static_pointer_cast<DrawableV2::RSDisplayRenderNodeDrawable>(params.GetAncestorDisplayDrawable().lock());
239     auto& uniParam = RSUniRenderThread::Instance().GetRSRenderThreadParams();
240     if (ancestorDisplayDrawable == nullptr || ancestorDisplayDrawable->GetRenderParams() == nullptr ||
241         uniParam == nullptr) {
242         RS_LOGE("%{public}s ancestorDisplayDrawable/ancestorDisplayDrawableParams/uniParam is nullptr", __func__);
243         return false;
244     } else {
245         auto displayParams = static_cast<RSDisplayRenderParams*>(ancestorDisplayDrawable->GetRenderParams().get());
246         forceClientForDRM = displayParams->IsRotationChanged() || uniParam->GetCacheEnabledForRotation();
247     }
248     return forceClientForDRM;
249 }
250 
GetLayerInfo(RSSurfaceRenderParams & params,sptr<SurfaceBuffer> & buffer,sptr<SurfaceBuffer> & preBuffer,const sptr<IConsumerSurface> & consumer,const sptr<SyncFence> & acquireFence)251 LayerInfoPtr RSUniRenderProcessor::GetLayerInfo(RSSurfaceRenderParams& params, sptr<SurfaceBuffer>& buffer,
252     sptr<SurfaceBuffer>& preBuffer, const sptr<IConsumerSurface>& consumer, const sptr<SyncFence>& acquireFence)
253 {
254     LayerInfoPtr layer = HdiLayerInfo::CreateHdiLayerInfo();
255     auto& layerInfo = params.layerInfo_;
256     layer->SetSurface(consumer);
257     layer->SetBuffer(buffer, acquireFence);
258     layer->SetPreBuffer(preBuffer);
259     params.SetPreBuffer(nullptr);
260     layer->SetZorder(layerInfo.zOrder);
261     layer->SetRotationFixed(params.GetFixRotationByUser());
262 
263     GraphicLayerAlpha alpha;
264     alpha.enGlobalAlpha = true;
265     // Alpha of 255 indicates opacity
266     alpha.gAlpha = static_cast<uint8_t>(std::clamp(layerInfo.alpha, 0.0f, 1.0f) * RGBA_MAX);
267     layer->SetAlpha(alpha);
268     layer->SetLayerSize(layerInfo.dstRect);
269     layer->SetBoundSize(layerInfo.boundRect);
270     bool forceClientForDRM = GetForceClientForDRM(params);
271     RS_OPTIONAL_TRACE_NAME_FMT("%s nodeName[%s] forceClientForDRM[%d]",
272         __func__, params.GetName().c_str(), forceClientForDRM);
273     RS_LOGD("%{public}s nodeName[%{public}s] forceClientForDRM[%{public}d]",
274         __func__, params.GetName().c_str(), forceClientForDRM);
275     bool forceClient = RSSystemProperties::IsForceClient() || forceClientForDRM;
276     layer->SetCompositionType(forceClient ? GraphicCompositionType::GRAPHIC_COMPOSITION_CLIENT :
277         GraphicCompositionType::GRAPHIC_COMPOSITION_DEVICE);
278     layer->SetCornerRadiusInfoForDRM(params.GetCornerRadiusInfoForDRM());
279     auto bufferBackgroundColor = params.GetBackgroundColor();
280     GraphicLayerColor backgroundColor = {
281         .r = bufferBackgroundColor.GetRed(),
282         .g = bufferBackgroundColor.GetGreen(),
283         .b = bufferBackgroundColor.GetBlue(),
284         .a = bufferBackgroundColor.GetAlpha()
285     };
286     layer->SetBackgroundColor(backgroundColor);
287 
288     std::vector<GraphicIRect> visibleRegions;
289     visibleRegions.emplace_back(layerInfo.dstRect);
290     layer->SetVisibleRegions(visibleRegions);
291     std::vector<GraphicIRect> dirtyRegions;
292     if (RSSystemProperties::GetHwcDirtyRegionEnabled()) {
293         const auto& dirtyRect = params.GetBufferDamage();
294         dirtyRegions.emplace_back(GraphicIRect { dirtyRect.x, dirtyRect.y, dirtyRect.w, dirtyRect.h });
295     } else {
296         dirtyRegions.emplace_back(layerInfo.srcRect);
297     }
298     layer->SetDirtyRegions(dirtyRegions);
299 
300     layer->SetBlendType(layerInfo.blendType);
301     ProcessLayerSetCropRect(layer, layerInfo, buffer);
302     layer->SetGravity(layerInfo.gravity);
303     layer->SetTransform(layerInfo.transformType);
304     auto matrix = GraphicMatrix {layerInfo.matrix.Get(Drawing::Matrix::Index::SCALE_X),
305         layerInfo.matrix.Get(Drawing::Matrix::Index::SKEW_X), layerInfo.matrix.Get(Drawing::Matrix::Index::TRANS_X),
306         layerInfo.matrix.Get(Drawing::Matrix::Index::SKEW_Y), layerInfo.matrix.Get(Drawing::Matrix::Index::SCALE_Y),
307         layerInfo.matrix.Get(Drawing::Matrix::Index::TRANS_Y), layerInfo.matrix.Get(Drawing::Matrix::Index::PERSP_0),
308         layerInfo.matrix.Get(Drawing::Matrix::Index::PERSP_1), layerInfo.matrix.Get(Drawing::Matrix::Index::PERSP_2)};
309     layer->SetMatrix(matrix);
310     layer->SetLayerSourceTuning(params.GetLayerSourceTuning());
311     layer->SetClearCacheSet(params.GetBufferClearCacheSet());
312     layer->SetLayerArsr(layerInfo.arsrTag);
313     return layer;
314 }
315 
ProcessLayerSetCropRect(LayerInfoPtr & layerInfoPtr,RSLayerInfo & layerInfo,sptr<SurfaceBuffer> buffer)316 void RSUniRenderProcessor::ProcessLayerSetCropRect(LayerInfoPtr& layerInfoPtr, RSLayerInfo& layerInfo,
317     sptr<SurfaceBuffer> buffer)
318 {
319     auto adaptedSrcRect = layerInfo.srcRect;
320     // Because the buffer is mirrored in the horiziontal/vertical directions,
321     // srcRect need to be adjusted.
322     switch (layerInfo.transformType) {
323         case GraphicTransformType::GRAPHIC_FLIP_H: [[fallthrough]];
324         case GraphicTransformType::GRAPHIC_FLIP_H_ROT180: {
325             // 1. Intersect the left border of the screen.
326             // map_x = (buffer_width - buffer_right_x)
327             if (adaptedSrcRect.x > 0) {
328                 adaptedSrcRect.x = buffer->GetSurfaceBufferWidth() - adaptedSrcRect.x - adaptedSrcRect.w;
329             } else if (layerInfo.dstRect.x + layerInfo.dstRect.w >= static_cast<int32_t>(screenInfo_.width)) {
330                 // 2. Intersect the right border of the screen.
331                 // map_x = (buffer_width - buffer_right_x)
332                 // Only left side adjustment can be triggerred on the narrow screen.
333                 adaptedSrcRect.x =
334                     buffer ? (static_cast<int32_t>(buffer->GetSurfaceBufferWidth()) - adaptedSrcRect.w) : 0;
335             }
336             break;
337         }
338         case GraphicTransformType::GRAPHIC_FLIP_V: [[fallthrough]];
339         case GraphicTransformType::GRAPHIC_FLIP_V_ROT180: {
340             // The processing in the vertical direction is similar to that in the horizontal direction.
341             if (adaptedSrcRect.y > 0) {
342                 adaptedSrcRect.y = buffer->GetSurfaceBufferHeight() - adaptedSrcRect.y - adaptedSrcRect.h;
343             } else if (layerInfo.dstRect.y + layerInfo.dstRect.h >= static_cast<int32_t>(screenInfo_.height)) {
344                 adaptedSrcRect.y =
345                     buffer ? (static_cast<int32_t>(buffer->GetSurfaceBufferHeight()) - adaptedSrcRect.h) : 0;
346             }
347             break;
348         }
349         default:
350             break;
351     }
352     layerInfoPtr->SetCropRect(adaptedSrcRect);
353 }
354 
ProcessSurface(RSSurfaceRenderNode & node)355 void RSUniRenderProcessor::ProcessSurface(RSSurfaceRenderNode &node)
356 {
357     RS_LOGE("It is update to DrawableV2 to process node now!!");
358 }
359 
ProcessSurfaceForRenderThread(DrawableV2::RSSurfaceRenderNodeDrawable & surfaceDrawable)360 void RSUniRenderProcessor::ProcessSurfaceForRenderThread(DrawableV2::RSSurfaceRenderNodeDrawable& surfaceDrawable)
361 {
362     auto layer = uniComposerAdapter_->CreateLayer(surfaceDrawable);
363     if (layer == nullptr) {
364         RS_LOGE("RSUniRenderProcessor::ProcessSurface: failed to createLayer for node(id: %{public}" PRIu64 ")",
365             surfaceDrawable.GetId());
366         return;
367     }
368     layers_.emplace_back(layer);
369 }
370 
ProcessDisplaySurface(RSDisplayRenderNode & node)371 void RSUniRenderProcessor::ProcessDisplaySurface(RSDisplayRenderNode& node)
372 {
373     auto layer = uniComposerAdapter_->CreateLayer(node);
374     if (layer == nullptr) {
375         RS_LOGE("RSUniRenderProcessor::ProcessDisplaySurface: failed to createLayer for node(id: %{public}" PRIu64 ")",
376             node.GetId());
377         return;
378     }
379     if (node.GetFingerprint()) {
380         layer->SetLayerMaskInfo(HdiLayerInfo::LayerMask::LAYER_MASK_HBM_SYNC);
381         RS_LOGD("RSUniRenderProcessor::ProcessDisplaySurface, set layer mask hbm sync");
382     } else {
383         layer->SetLayerMaskInfo(HdiLayerInfo::LayerMask::LAYER_MASK_NORMAL);
384     }
385     layers_.emplace_back(layer);
386     layerNum_ = node.GetSurfaceCountForMultiLayersPerf();
387     auto drawable = node.GetRenderDrawable();
388     if (!drawable) {
389         return;
390     }
391     auto displayDrawable = std::static_pointer_cast<DrawableV2::RSDisplayRenderNodeDrawable>(drawable);
392     auto surfaceHandler = displayDrawable->GetRSSurfaceHandlerOnDraw();
393     RSUniRenderThread::Instance().SetAcquireFence(surfaceHandler->GetAcquireFence());
394 }
395 
ProcessDisplaySurfaceForRenderThread(DrawableV2::RSDisplayRenderNodeDrawable & displayDrawable)396 void RSUniRenderProcessor::ProcessDisplaySurfaceForRenderThread(
397     DrawableV2::RSDisplayRenderNodeDrawable& displayDrawable)
398 {
399     auto layer = uniComposerAdapter_->CreateLayer(displayDrawable);
400     if (layer == nullptr) {
401         RS_LOGE("RSUniRenderProcessor::ProcessDisplaySurface: failed to createLayer for node(id: %{public}" PRIu64 ")",
402             displayDrawable.GetId());
403         return;
404     }
405     auto& params = displayDrawable.GetRenderParams();
406     if (!params) {
407         return;
408     }
409     if (params->GetFingerprint()) {
410         layer->SetLayerMaskInfo(HdiLayerInfo::LayerMask::LAYER_MASK_HBM_SYNC);
411         RS_LOGD("RSUniRenderProcessor::ProcessDisplaySurface, set layer mask hbm sync");
412     } else {
413         layer->SetLayerMaskInfo(HdiLayerInfo::LayerMask::LAYER_MASK_NORMAL);
414     }
415     layers_.emplace_back(layer);
416     auto displayParams = static_cast<RSDisplayRenderParams*>(params.get());
417     for (const auto& drawable : displayParams->GetAllMainAndLeashSurfaceDrawables()) {
418         auto surfaceDrawable = std::static_pointer_cast<DrawableV2::RSSurfaceRenderNodeDrawable>(drawable);
419         if (!surfaceDrawable || !surfaceDrawable->GetRenderParams() ||
420             !surfaceDrawable->GetRenderParams()->GetOcclusionVisible() ||
421             surfaceDrawable->GetRenderParams()->IsLeashWindow()) {
422             continue;
423         }
424         layerNum_++;
425     }
426     auto surfaceHandler = displayDrawable.GetRSSurfaceHandlerOnDraw();
427     if (!surfaceHandler) {
428         return;
429     }
430     RSUniRenderThread::Instance().SetAcquireFence(surfaceHandler->GetAcquireFence());
431 }
432 
ProcessRcdSurface(RSRcdSurfaceRenderNode & node)433 void RSUniRenderProcessor::ProcessRcdSurface(RSRcdSurfaceRenderNode& node)
434 {
435     auto layer = uniComposerAdapter_->CreateLayer(node);
436     if (layer == nullptr) {
437         RS_LOGE("RSUniRenderProcessor::ProcessRcdSurface: failed to createLayer for node(id: %{public}" PRIu64 ")",
438             node.GetId());
439         return;
440     }
441     layers_.emplace_back(layer);
442 }
443 
444 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
GetLayers() const445 std::vector<LayerInfoPtr> RSUniRenderProcessor::GetLayers() const
446 {
447     return layers_;
448 }
449 #endif
450 } // namespace Rosen
451 } // namespace OHOS
452