1 /*
2 * Copyright (c) 2023 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_driven_render_visitor.h"
17
18 #include "common/rs_common_def.h"
19 #include "common/rs_obj_abs_geometry.h"
20 #include "pipeline/rs_base_render_node.h"
21 #include "pipeline/rs_base_render_util.h"
22 #include "pipeline/rs_canvas_render_node.h"
23 #include "pipeline/rs_main_thread.h"
24 #include "pipeline/rs_surface_render_node.h"
25 #include "platform/common/rs_log.h"
26 #include "property/rs_properties_painter.h"
27 #include "rs_driven_render_listener.h"
28 #include "rs_trace.h"
29
30 namespace OHOS {
31 namespace Rosen {
RSDrivenRenderVisitor()32 RSDrivenRenderVisitor::RSDrivenRenderVisitor()
33 {
34 auto mainThread = RSMainThread::Instance();
35 renderEngine_ = mainThread->GetRenderEngine();
36 }
37
PrepareChildren(RSRenderNode & node)38 void RSDrivenRenderVisitor::PrepareChildren(RSRenderNode& node)
39 {
40 node.ApplyChildrenModifiers();
41 for (auto& child : node.GetSortedChildren()) {
42 child->Prepare(shared_from_this());
43 }
44 }
45
PrepareCanvasRenderNode(RSCanvasRenderNode & node)46 void RSDrivenRenderVisitor::PrepareCanvasRenderNode(RSCanvasRenderNode& node)
47 {
48 auto rsParent = (node.GetParent().lock());
49 if (rsParent && rsParent->IsMarkDrivenRender()) {
50 auto paintItem = node.GetRenderProperties().GetFrame();
51 int32_t itemIndex = node.GetItemIndex();
52 currDrivenSurfaceNode_->PushFramePaintItem(paintItem, itemIndex);
53 return;
54 }
55 PrepareChildren(node);
56 }
57
PrepareDrivenSurfaceRenderNode(RSDrivenSurfaceRenderNode & node)58 void RSDrivenRenderVisitor::PrepareDrivenSurfaceRenderNode(RSDrivenSurfaceRenderNode& node)
59 {
60 if (node.IsInvalidSurface()) {
61 return;
62 }
63 currDrivenSurfaceNode_ = std::static_pointer_cast<RSDrivenSurfaceRenderNode>(node.shared_from_this());
64 auto canvasNode = RSBaseRenderNode::ReinterpretCast<RSCanvasRenderNode>(node.GetDrivenCanvasNode());
65 if (canvasNode == nullptr) {
66 RS_LOGE("RSDrivenRenderVisitor:: Driven canvasNode is null!");
67 return;
68 }
69 auto& property = canvasNode->GetRenderProperties();
70
71 if (node.IsContentSurface()) {
72 PrepareCanvasRenderNode(*canvasNode);
73 }
74
75 auto geoPtr = (property.GetBoundsGeometry());
76 RectF surfaceBounds = RectF(0, 0, screenRect_.GetWidth(), screenRect_.GetHeight());
77 RectF viewPort = RectF(0, 0, screenRect_.GetWidth(), screenRect_.GetHeight());
78 RectI dstRect = screenRect_;
79 RectI contentAbsRect = geoPtr->GetAbsRect();
80
81 if (node.IsContentSurface()) {
82 surfaceBounds = property.GetBoundsRect();
83 viewPort = property.GetBoundsRect();
84 dstRect = geoPtr->GetAbsRect();
85 if (property.GetClipToFrame()) {
86 viewPort = RectF(property.GetFrameOffsetX(), property.GetFrameOffsetY(),
87 property.GetFrameWidth(), property.GetFrameHeight());
88 dstRect = geoPtr->MapAbsRect(viewPort);
89 }
90 auto cmdsClipFrameRect = canvasNode->GetDrivenContentClipFrameRect();
91 if (!cmdsClipFrameRect.IsEmpty()) {
92 viewPort = cmdsClipFrameRect;
93 dstRect = geoPtr->MapAbsRect(viewPort);
94 }
95 }
96 currDrivenSurfaceNode_->SetCurrFrameBounds(surfaceBounds, viewPort, contentAbsRect);
97 currDrivenSurfaceNode_->UpdateActivateFrameState(dstRect, backgroundDirty_, contentDirty_, nonContentDirty_);
98 RS_LOGD("RSDrivenRenderVisitor::PrepareDrivenSurfaceRenderNode DstRect = %s, SrcRect = %s",
99 node.GetDstRect().ToString().c_str(), node.GetSrcRect().ToString().c_str());
100 }
101
ProcessChildren(RSRenderNode & node)102 void RSDrivenRenderVisitor::ProcessChildren(RSRenderNode& node)
103 {
104 if (hasTraverseDrivenNode_ && currDrivenSurfaceNode_->IsBackgroundSurface()) {
105 return;
106 }
107 for (auto& child : node.GetSortedChildren()) {
108 child->Process(shared_from_this());
109 }
110 }
111
ProcessCanvasRenderNode(RSCanvasRenderNode & node)112 void RSDrivenRenderVisitor::ProcessCanvasRenderNode(RSCanvasRenderNode& node)
113 {
114 if (!node.ShouldPaint()) {
115 RS_LOGE("RSDrivenRenderVisitor::ProcessCanvasRenderNode, no need process");
116 return;
117 }
118 if (!canvas_) {
119 RS_LOGE("RSDrivenRenderVisitor::ProcessCanvasRenderNode, canvas is nullptr");
120 return;
121 }
122 if (node.IsMarkDrivenRender()) {
123 hasTraverseDrivenNode_ = true;
124 ProcessDrivenCanvasRenderNode(node);
125 return;
126 }
127 if (hasTraverseDrivenNode_ && currDrivenSurfaceNode_->IsBackgroundSurface()) {
128 return;
129 }
130 node.ProcessRenderBeforeChildren(*canvas_);
131 node.ProcessRenderContents(*canvas_);
132 ProcessChildren(node);
133 node.ProcessRenderAfterChildren(*canvas_);
134 }
135
ProcessDrivenSurfaceRenderNode(RSDrivenSurfaceRenderNode & node)136 void RSDrivenRenderVisitor::ProcessDrivenSurfaceRenderNode(RSDrivenSurfaceRenderNode& node)
137 {
138 if (node.IsExpandedMode()) {
139 RS_TRACE_NAME("RSUniRender:DrivenRenderExFrame");
140 RenderExpandedFrame(node);
141 } else if (node.IsReusableMode()) {
142 RS_TRACE_NAME("RSUniRender:DrivenRenderReuse");
143 SkipRenderExpandedFrame(node);
144 } else {
145 RS_TRACE_NAME("RSUniRender:DrivenRenderDisable");
146 }
147 }
148
ProcessDrivenCanvasRenderNode(RSCanvasRenderNode & node)149 void RSDrivenRenderVisitor::ProcessDrivenCanvasRenderNode(RSCanvasRenderNode& node)
150 {
151 if (currDrivenSurfaceNode_->IsBackgroundSurface()) {
152 node.ProcessDrivenBackgroundRender(*canvas_);
153 } else {
154 node.ProcessDrivenContentRender(*canvas_);
155 ProcessChildren(node);
156 node.ProcessDrivenContentRenderAfterChildren(*canvas_);
157 }
158 }
159
SetDirtyInfo(bool backgroundDirty,bool contentDirty,bool nonContentDirty)160 void RSDrivenRenderVisitor::SetDirtyInfo(bool backgroundDirty, bool contentDirty, bool nonContentDirty)
161 {
162 backgroundDirty_ = backgroundDirty;
163 contentDirty_ = contentDirty;
164 nonContentDirty_ = nonContentDirty;
165 }
166
SetScreenRect(const RectI & rect)167 void RSDrivenRenderVisitor::SetScreenRect(const RectI& rect)
168 {
169 screenRect_ = rect;
170 }
171
SetUniProcessor(std::shared_ptr<RSProcessor> processor)172 void RSDrivenRenderVisitor::SetUniProcessor(std::shared_ptr<RSProcessor> processor)
173 {
174 uniProcessor_ = processor;
175 }
176
SetUniColorSpace(GraphicColorGamut colorSpace)177 void RSDrivenRenderVisitor::SetUniColorSpace(GraphicColorGamut colorSpace)
178 {
179 uniColorSpace_ = colorSpace;
180 }
181
SetUniGlobalZOrder(float globalZOrder)182 void RSDrivenRenderVisitor::SetUniGlobalZOrder(float globalZOrder)
183 {
184 uniGlobalZOrder_ = globalZOrder;
185 }
186
RenderExpandedFrame(RSDrivenSurfaceRenderNode & node)187 void RSDrivenRenderVisitor::RenderExpandedFrame(RSDrivenSurfaceRenderNode& node)
188 {
189 if (uniProcessor_ == nullptr) {
190 RS_LOGE("RSDrivenRenderVisitor RSProcessor is null!");
191 return;
192 }
193
194 auto canvasNode = RSBaseRenderNode::ReinterpretCast<RSCanvasRenderNode>(node.GetDrivenCanvasNode());
195 if (canvasNode == nullptr) {
196 RS_LOGE("RSDrivenRenderVisitor canvasNode is null!");
197 return;
198 }
199
200 if (node.IsInvalidSurface()) {
201 RS_LOGE("RSDrivenRenderVisitor DrivenSurfaceType is NONE!");
202 return;
203 }
204
205 currDrivenSurfaceNode_ = std::static_pointer_cast<RSDrivenSurfaceRenderNode>(node.shared_from_this());
206 hasTraverseDrivenNode_ = false;
207
208 auto surfaceNodePtr = node.ReinterpretCastTo<RSDrivenSurfaceRenderNode>();
209 if (!node.IsSurfaceCreated()) {
210 sptr<IBufferConsumerListener> listener = new RSDrivenRenderListener(surfaceNodePtr);
211 if (!node.CreateSurface(listener)) {
212 RS_LOGE("RSDrivenRenderVisitor::RenderExpandedFrame CreateSurface failed");
213 return;
214 }
215 }
216 auto rsSurface = node.GetRSSurface();
217 if (rsSurface == nullptr) {
218 RS_LOGE("RSDrivenRenderVisitor::RenderExpandedFrame no RSSurface found");
219 return;
220 }
221 rsSurface->SetColorSpace(uniColorSpace_);
222 #ifdef NEW_RENDER_CONTEXT
223 auto renderFrame = renderEngine_->RequestFrame(std::static_pointer_cast<RSRenderSurfaceOhos>(rsSurface),
224 node.GetBufferRequestConfig());
225 #else
226 auto renderFrame = renderEngine_->RequestFrame(std::static_pointer_cast<RSSurfaceOhos>(rsSurface),
227 node.GetBufferRequestConfig());
228 #endif
229 if (renderFrame == nullptr) {
230 RS_LOGE("RSDrivenRenderVisitor Request Frame Failed");
231 return;
232 }
233 #ifdef NEW_RENDER_CONTEXT
234 if (renderFrame->GetSurface() == nullptr) {
235 RS_LOGE("RSDrivenRenderVisitor::RenderExpandedFrame: RSSurfaceFrame is null");
236 return;
237 }
238 auto skSurface = renderFrame->GetSurface()->GetSurface();
239 #else
240 if (renderFrame->GetFrame() == nullptr) {
241 RS_LOGE("RSDrivenRenderVisitor::RenderExpandedFrame: RSSurfaceFrame is null");
242 return;
243 }
244 auto skSurface = renderFrame->GetFrame()->GetSurface();
245 #endif
246 if (skSurface == nullptr) {
247 RS_LOGE("RSDrivenRenderVisitor::RenderExpandedFrame: skSurface is null");
248 return;
249 }
250 if (skSurface->getCanvas() == nullptr) {
251 ROSEN_LOGE("RSDrivenRenderVisitor skSurface.getCanvas is null.");
252 return;
253 }
254 canvas_ = std::make_shared<RSPaintFilterCanvas>(skSurface.get());
255 canvas_->save();
256 canvas_->translate(node.GetFrameOffsetX(), node.GetFrameOffsetY());
257 canvas_->clipRect(SkRect::MakeLTRB(node.GetFrameClipRect().GetLeft(), node.GetFrameClipRect().GetTop(),
258 node.GetFrameClipRect().GetRight(), node.GetFrameClipRect().GetBottom()));
259 canvas_->clear(SK_ColorTRANSPARENT);
260
261 if (node.IsBackgroundSurface()) {
262 RS_LOGD("RSDrivenRenderVisitor process BACKGROUND");
263 auto rsDrivenParent = RSBaseRenderNode::ReinterpretCast<RSSurfaceRenderNode>(canvasNode->GetParent().lock());
264 if (rsDrivenParent == nullptr) {
265 return;
266 }
267 auto geoPtr = (
268 rsDrivenParent->GetRenderProperties().GetBoundsGeometry());
269 canvas_->concat(geoPtr->GetAbsMatrix());
270 } else {
271 RS_LOGD("RSDrivenRenderVisitor process CONTENT");
272 }
273
274 ProcessCanvasRenderNode(*canvasNode);
275 canvas_->restore();
276 renderFrame->Flush();
277 RS_TRACE_BEGIN("RSUniRender:WaitUtilDrivenRenderFinished");
278 RSMainThread::Instance()->WaitUtilDrivenRenderFinished();
279 RS_TRACE_END();
280 float globalZOrder = node.IsContentSurface() ? uniGlobalZOrder_ - 1 : uniGlobalZOrder_ - 2;
281 node.SetGlobalZOrder(globalZOrder);
282 uniProcessor_->ProcessDrivenSurface(node);
283 }
284
SkipRenderExpandedFrame(RSDrivenSurfaceRenderNode & node)285 void RSDrivenRenderVisitor::SkipRenderExpandedFrame(RSDrivenSurfaceRenderNode& node)
286 {
287 if (uniProcessor_ == nullptr) {
288 RS_LOGE("RSDrivenRenderVisitor RSProcessor is null!");
289 return;
290 }
291 if (node.IsBackgroundSurface()) {
292 RS_LOGD("RSDrivenRenderVisitor skip process BACKGROUND");
293 } else {
294 RS_LOGD("RSDrivenRenderVisitor skip process CONTENT");
295 }
296 float globalZOrder = node.IsContentSurface() ? uniGlobalZOrder_ - 1 : uniGlobalZOrder_ - 2;
297 node.SetGlobalZOrder(globalZOrder);
298 uniProcessor_->ProcessDrivenSurface(node);
299 }
300 } // namespace Rosen
301 } // namespace OHOS
302