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 "pipeline/rs_effect_render_node.h"
17
18 #include "common/rs_obj_abs_geometry.h"
19 #include "common/rs_optional_trace.h"
20 #include "memory/rs_memory_track.h"
21 #include "params/rs_effect_render_params.h"
22 #include "platform/common/rs_log.h"
23 #include "platform/common/rs_system_properties.h"
24 #include "property/rs_properties_painter.h"
25 #include "visitor/rs_node_visitor.h"
26
27 namespace OHOS {
28 namespace Rosen {
29
RSEffectRenderNode(NodeId id,const std::weak_ptr<RSContext> & context,bool isTextureExportNode)30 RSEffectRenderNode::RSEffectRenderNode(NodeId id, const std::weak_ptr<RSContext>& context, bool isTextureExportNode)
31 : RSRenderNode(id, context, isTextureExportNode)
32 {
33 #ifndef ROSEN_ARKUI_X
34 MemoryInfo info = { sizeof(*this), ExtractPid(id), id, MEMORY_TYPE::MEM_RENDER_NODE };
35 MemoryTrack::Instance().AddNodeRecord(id, info);
36 #endif
37 MemorySnapshot::Instance().AddCpuMemory(ExtractPid(id), sizeof(*this));
38 }
39
~RSEffectRenderNode()40 RSEffectRenderNode::~RSEffectRenderNode()
41 {
42 #ifndef ROSEN_ARKUI_X
43 MemoryTrack::Instance().RemoveNodeRecord(GetId());
44 #endif
45 MemorySnapshot::Instance().RemoveCpuMemory(ExtractPid(GetId()), sizeof(*this));
46 }
47
Prepare(const std::shared_ptr<RSNodeVisitor> & visitor)48 void RSEffectRenderNode::Prepare(const std::shared_ptr<RSNodeVisitor>& visitor)
49 {
50 if (!visitor) {
51 return;
52 }
53 ApplyModifiers();
54 visitor->PrepareEffectRenderNode(*this);
55 }
56
QuickPrepare(const std::shared_ptr<RSNodeVisitor> & visitor)57 void RSEffectRenderNode::QuickPrepare(const std::shared_ptr<RSNodeVisitor>& visitor)
58 {
59 if (!visitor) {
60 return;
61 }
62 ApplyModifiers();
63 visitor->QuickPrepareEffectRenderNode(*this);
64 }
65
Process(const std::shared_ptr<RSNodeVisitor> & visitor)66 void RSEffectRenderNode::Process(const std::shared_ptr<RSNodeVisitor>& visitor)
67 {
68 if (!visitor) {
69 return;
70 }
71 RSRenderNode::RenderTraceDebug();
72 visitor->ProcessEffectRenderNode(*this);
73 }
74
ProcessRenderBeforeChildren(RSPaintFilterCanvas & canvas)75 void RSEffectRenderNode::ProcessRenderBeforeChildren(RSPaintFilterCanvas& canvas)
76 {
77 RSRenderNode::ProcessTransitionBeforeChildren(canvas);
78 auto& properties = GetRenderProperties();
79 // Disable effect region if either of the following conditions is met:
80 // 1. No child with useEffect(true) (needFilter_ == false)
81 // 2. Background filter is null
82 // 3. Canvas is offscreen
83 if (!properties.GetHaveEffectRegion() || properties.GetBackgroundFilter() == nullptr ||
84 !RSSystemProperties::GetEffectMergeEnabled() ||
85 canvas.GetCacheType() == RSPaintFilterCanvas::CacheType::OFFSCREEN) {
86 canvas.SetEffectData(nullptr);
87 return;
88 }
89
90 if (properties.GetBgImage() == nullptr) {
91 // EffectRenderNode w/o background image, use snapshot as underlay image
92 RSPropertiesPainter::DrawBackgroundEffect(properties, canvas);
93 } else {
94 // EffectRenderNode w/ background image, use bg image as underlay image
95 RSPropertiesPainter::DrawBackgroundImageAsEffect(properties, canvas);
96 }
97 }
98
GetFilterRect() const99 RectI RSEffectRenderNode::GetFilterRect() const
100 {
101 if (!ChildHasVisibleEffect()) {
102 return {};
103 }
104 return RSRenderNode::GetFilterRect();
105 }
106
SetEffectRegion(const std::optional<Drawing::RectI> & effectRegion)107 void RSEffectRenderNode::SetEffectRegion(const std::optional<Drawing::RectI>& effectRegion)
108 {
109 if (!effectRegion.has_value() || !effectRegion->IsValid()) {
110 ROSEN_LOGD("RSEffectRenderNode::SetEffectRegion: no effect region.");
111 GetMutableRenderProperties().SetHaveEffectRegion(false);
112 return;
113 }
114
115 const auto& properties = GetRenderProperties();
116 const auto& absRect = properties.GetBoundsGeometry()->GetAbsRect();
117 Drawing::RectI effectRect = effectRegion.value();
118 if (!effectRect.Intersect(
119 Drawing::RectI(absRect.GetLeft(), absRect.GetTop(), absRect.GetRight(), absRect.GetBottom()))) {
120 ROSEN_LOGD("RSEffectRenderNode::SetEffectRegion: no valid effect region.");
121 GetMutableRenderProperties().SetHaveEffectRegion(false);
122 return;
123 }
124 GetMutableRenderProperties().SetHaveEffectRegion(true);
125 }
126
CheckBlurFilterCacheNeedForceClearOrSave(bool rotationChanged,bool rotationStatusChanged)127 void RSEffectRenderNode::CheckBlurFilterCacheNeedForceClearOrSave(bool rotationChanged, bool rotationStatusChanged)
128 {
129 if (GetRenderProperties().GetBackgroundFilter() == nullptr) {
130 return;
131 }
132 auto filterDrawable = GetFilterDrawable(false);
133 if (filterDrawable == nullptr) {
134 return;
135 }
136 filterDrawable->MarkEffectNode();
137 RSRenderNode::CheckBlurFilterCacheNeedForceClearOrSave(rotationChanged, rotationStatusChanged);
138 if (IsForceClearOrUseFilterCache(filterDrawable)) {
139 return;
140 }
141 if (CheckFilterCacheNeedForceClear()) {
142 filterDrawable->MarkFilterForceClearCache();
143 } else if (CheckFilterCacheNeedForceSave()) {
144 filterDrawable->MarkFilterForceUseCache();
145 }
146 }
147
UpdateFilterCacheWithSelfDirty()148 void RSEffectRenderNode::UpdateFilterCacheWithSelfDirty()
149 {
150 if (!RSProperties::FilterCacheEnabled) {
151 ROSEN_LOGE("RSEffectRenderNode::UpdateFilterCacheManagerWithCacheRegion filter cache is disabled.");
152 return;
153 }
154 auto filterDrawable = GetFilterDrawable(false);
155 if (filterDrawable == nullptr || IsForceClearOrUseFilterCache(filterDrawable)) {
156 return;
157 }
158 RS_OPTIONAL_TRACE_NAME_FMT("RSEffectRenderNode[%llu]::UpdateFilterCacheWithSelfDirty lastRect:%s, currRegion:%s",
159 GetId(), GetFilterCachedRegion().ToString().c_str(), filterRegion_.ToString().c_str());
160 if (filterRegion_ == GetFilterCachedRegion()) {
161 return;
162 }
163 // effect render node only support background filter
164 MarkFilterStatusChanged(false, true);
165 }
166
MarkFilterCacheFlags(std::shared_ptr<DrawableV2::RSFilterDrawable> & filterDrawable,RSDirtyRegionManager & dirtyManager,bool needRequestNextVsync)167 void RSEffectRenderNode::MarkFilterCacheFlags(std::shared_ptr<DrawableV2::RSFilterDrawable>& filterDrawable,
168 RSDirtyRegionManager& dirtyManager, bool needRequestNextVsync)
169 {
170 lastFrameHasVisibleEffect_ = ChildHasVisibleEffect();
171 if (filterDrawable == nullptr || IsForceClearOrUseFilterCache(filterDrawable)) {
172 return;
173 }
174 // use for skip-frame when screen rotation
175 if (isRotationChanged_) {
176 filterDrawable->MarkRotationChanged();
177 }
178 RSRenderNode::MarkFilterCacheFlags(filterDrawable, dirtyManager, needRequestNextVsync);
179 }
180
CheckFilterCacheNeedForceSave()181 bool RSEffectRenderNode::CheckFilterCacheNeedForceSave()
182 {
183 RS_OPTIONAL_TRACE_NAME_FMT("RSEffectRenderNode[%llu]::CheckFilterCacheNeedForceSave"
184 " isBackgroundImage:%d, isRotationChanged_:%d, IsStaticCached():%d,",
185 GetId(), GetRenderProperties().GetBgImage() != nullptr, isRotationChanged_, IsStaticCached());
186 return GetRenderProperties().GetBgImage() != nullptr || (IsStaticCached() && !isRotationChanged_);
187 }
188
CheckFilterCacheNeedForceClear()189 bool RSEffectRenderNode::CheckFilterCacheNeedForceClear()
190 {
191 RS_OPTIONAL_TRACE_NAME_FMT("RSEffectRenderNode[%llu]::CheckFilterCacheNeedForceClear foldStatusChanged_:%d,"
192 " preRotationStatus_:%d, isRotationChanged_:%d, preStaticStatus_:%d, isStaticCached:%d",
193 GetId(), foldStatusChanged_, preRotationStatus_, isRotationChanged_, preStaticStatus_, IsStaticCached());
194 // case 3: the state of freeze changed to false, and the last cache maybe wrong.
195 bool res = foldStatusChanged_ || (preRotationStatus_ != isRotationChanged_) ||
196 (preStaticStatus_ != isStaticCached_ && isStaticCached_ == false);
197 preStaticStatus_ = IsStaticCached();
198 return res;
199 }
200
SetRotationChanged(bool isRotationChanged)201 void RSEffectRenderNode::SetRotationChanged(bool isRotationChanged)
202 {
203 preRotationStatus_ = isRotationChanged_;
204 isRotationChanged_ = isRotationChanged;
205 }
206
GetRotationChanged() const207 bool RSEffectRenderNode::GetRotationChanged() const
208 {
209 return isRotationChanged_;
210 }
211
SetCurrentAttachedScreenId(uint64_t screenId)212 void RSEffectRenderNode::SetCurrentAttachedScreenId(uint64_t screenId)
213 {
214 currentAttachedScreenId_ = screenId;
215 }
216
GetCurrentAttachedScreenId() const217 uint64_t RSEffectRenderNode::GetCurrentAttachedScreenId() const
218 {
219 return currentAttachedScreenId_;
220 }
221
SetFoldStatusChanged(bool foldStatusChanged)222 void RSEffectRenderNode::SetFoldStatusChanged(bool foldStatusChanged)
223 {
224 foldStatusChanged_ = foldStatusChanged;
225 }
226
InitRenderParams()227 void RSEffectRenderNode::InitRenderParams()
228 {
229 stagingRenderParams_ = std::make_unique<RSEffectRenderParams>(GetId());
230 DrawableV2::RSRenderNodeDrawableAdapter::OnGenerate(shared_from_this());
231 if (renderDrawable_ == nullptr) {
232 RS_LOGE("RSEffectRenderNode::InitRenderParams failed");
233 return;
234 }
235 }
236
MarkFilterHasEffectChildren()237 void RSEffectRenderNode::MarkFilterHasEffectChildren()
238 {
239 if (GetRenderProperties().GetBackgroundFilter() == nullptr) {
240 return;
241 }
242 auto effectParams = static_cast<RSEffectRenderParams*>(stagingRenderParams_.get());
243 if (effectParams == nullptr) {
244 return;
245 }
246 effectParams->SetHasEffectChildren(ChildHasVisibleEffect());
247 if (!RSProperties::FilterCacheEnabled) {
248 UpdateDirtySlotsAndPendingNodes(RSDrawableSlot::BACKGROUND_FILTER);
249 }
250 }
251
OnFilterCacheStateChanged()252 void RSEffectRenderNode::OnFilterCacheStateChanged()
253 {
254 auto filterDrawable = GetFilterDrawable(false);
255 auto effectParams = static_cast<RSEffectRenderParams*>(stagingRenderParams_.get());
256 if (filterDrawable == nullptr || effectParams == nullptr) {
257 return;
258 }
259 effectParams->SetCacheValid(filterDrawable->IsFilterCacheValid());
260 }
261
EffectNodeShouldPaint() const262 bool RSEffectRenderNode::EffectNodeShouldPaint() const
263 {
264 return ChildHasVisibleEffect();
265 }
266
FirstFrameHasEffectChildren() const267 bool RSEffectRenderNode::FirstFrameHasEffectChildren() const
268 {
269 RS_OPTIONAL_TRACE_NAME_FMT("RSEffectRenderNode[%llu]::FirstFrameHasEffectChildren lastHasVisibleEffect:%d,"
270 "hasVisibleEffect:%d", GetId(), lastFrameHasVisibleEffect_, ChildHasVisibleEffect());
271 return GetRenderProperties().GetBackgroundFilter() != nullptr &&
272 !lastFrameHasVisibleEffect_ && ChildHasVisibleEffect();
273 }
274
FirstFrameHasNoEffectChildren() const275 bool RSEffectRenderNode::FirstFrameHasNoEffectChildren() const
276 {
277 return GetRenderProperties().GetBackgroundFilter() != nullptr &&
278 !ChildHasVisibleEffect() && lastFrameHasVisibleEffect_;
279 }
280
MarkClearFilterCacheIfEffectChildrenChanged()281 void RSEffectRenderNode::MarkClearFilterCacheIfEffectChildrenChanged()
282 {
283 // the first frame node has no effect child, it should not be painted and filter cache need to be cleared.
284 auto filterDrawable = GetFilterDrawable(false);
285 if (filterDrawable == nullptr || filterDrawable->IsForceClearFilterCache()) {
286 return;
287 }
288 if (!FirstFrameHasEffectChildren() && !FirstFrameHasNoEffectChildren()) {
289 return;
290 }
291 filterDrawable->MarkFilterForceClearCache();
292 // the first frame node has no effect child, force use cache should be cancled.
293 if (filterDrawable->IsForceUseFilterCache()) {
294 filterDrawable->MarkFilterForceUseCache(false);
295 }
296 }
297 } // namespace Rosen
298 } // namespace OHOS
299