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 #include "drawable/rs_property_drawable.h"
17
18 #include "rs_trace.h"
19
20 #include "common/rs_optional_trace.h"
21 #include "drawable/rs_property_drawable_utils.h"
22 #include "ge_visual_effect_container.h"
23 #include "gfx/performance/rs_perfmonitor_reporter.h"
24 #include "hpae_base/rs_hpae_filter_cache_manager.h"
25 #include "memory/rs_tag_tracker.h"
26 #include "pipeline/rs_recording_canvas.h"
27 #include "pipeline/rs_render_node.h"
28 #include "pipeline/rs_surface_render_node.h"
29 #include "platform/common/rs_log.h"
30 #include "property/rs_properties.h"
31 #include "render/rs_drawing_filter.h"
32 #include "render/rs_effect_luminance_manager.h"
33 #include "render/rs_filter_cache_manager.h"
34 #include "render/rs_render_linear_gradient_blur_filter.h"
35
36 namespace OHOS::Rosen {
37 namespace DrawableV2 {
38 constexpr int TRACE_LEVEL_TWO = 2;
OnSync()39 void RSPropertyDrawable::OnSync()
40 {
41 if (!needSync_) {
42 return;
43 }
44 std::swap(drawCmdList_, stagingDrawCmdList_);
45 propertyDescription_ = stagingPropertyDescription_;
46 stagingPropertyDescription_.clear();
47 needSync_ = false;
48 }
49
OnPurge()50 void RSPropertyDrawable::OnPurge()
51 {
52 if (drawCmdList_) {
53 drawCmdList_->Purge();
54 }
55 }
56
CreateDrawFunc() const57 Drawing::RecordingCanvas::DrawFunc RSPropertyDrawable::CreateDrawFunc() const
58 {
59 auto ptr = std::static_pointer_cast<const RSPropertyDrawable>(shared_from_this());
60 return [ptr](Drawing::Canvas* canvas, const Drawing::Rect* rect) {
61 #ifdef RS_ENABLE_GPU
62 RSTagTracker tagTracker(canvas ? canvas->GetGPUContext() : nullptr,
63 RSTagTracker::SOURCETYPE::SOURCE_RSPROPERTYDRAWABLE);
64 #endif
65 ptr->drawCmdList_->Playback(*canvas);
66 if (!ptr->propertyDescription_.empty()) {
67 RS_OPTIONAL_TRACE_NAME_FMT_LEVEL(TRACE_LEVEL_TWO, "RSPropertyDrawable:: %s, bounds:%s",
68 ptr->propertyDescription_.c_str(), rect->ToString().c_str());
69 }
70 };
71 }
72
73 // ============================================================================
74 // Updater
RSPropertyDrawCmdListUpdater(int width,int height,RSPropertyDrawable * target)75 RSPropertyDrawCmdListUpdater::RSPropertyDrawCmdListUpdater(int width, int height, RSPropertyDrawable* target)
76 : target_(target)
77 {
78 // PLANNING: use RSRenderNode to determine the correct recording canvas size
79 recordingCanvas_ = ExtendRecordingCanvas::Obtain(10, 10, false); // width 10, height 10
80 }
81
~RSPropertyDrawCmdListUpdater()82 RSPropertyDrawCmdListUpdater::~RSPropertyDrawCmdListUpdater()
83 {
84 if (recordingCanvas_ && target_) {
85 target_->stagingDrawCmdList_ = recordingCanvas_->GetDrawCmdList();
86 target_->needSync_ = true;
87 ExtendRecordingCanvas::Recycle(recordingCanvas_);
88 recordingCanvas_.reset();
89 target_ = nullptr;
90 } else {
91 ROSEN_LOGE("Update failed, recording canvas is null!");
92 }
93 }
94
GetRecordingCanvas() const95 const std::unique_ptr<ExtendRecordingCanvas>& RSPropertyDrawCmdListUpdater::GetRecordingCanvas() const
96 {
97 return recordingCanvas_;
98 }
99
100 // ============================================================================
OnGenerate(const RSRenderNode & node)101 RSDrawable::Ptr RSFrameOffsetDrawable::OnGenerate(const RSRenderNode& node)
102 {
103 if (auto ret = std::make_shared<RSFrameOffsetDrawable>(); ret->OnUpdate(node)) {
104 return std::move(ret);
105 }
106 return nullptr;
107 };
108
OnUpdate(const RSRenderNode & node)109 bool RSFrameOffsetDrawable::OnUpdate(const RSRenderNode& node)
110 {
111 const RSProperties& properties = node.GetRenderProperties();
112 auto frameOffsetX = properties.GetFrameOffsetX();
113 auto frameOffsetY = properties.GetFrameOffsetY();
114 if (frameOffsetX == 0 && frameOffsetY == 0) {
115 return false;
116 }
117
118 // regenerate stagingDrawCmdList_
119 RSPropertyDrawCmdListUpdater updater(0, 0, this);
120 updater.GetRecordingCanvas()->Translate(frameOffsetX, frameOffsetY);
121 return true;
122 }
123
124 // ============================================================================
OnGenerate(const RSRenderNode & node)125 RSDrawable::Ptr RSClipToBoundsDrawable::OnGenerate(const RSRenderNode& node)
126 {
127 auto ret = std::make_shared<RSClipToBoundsDrawable>();
128 ret->OnUpdate(node);
129 ret->OnSync();
130 return std::move(ret);
131 };
132
OnUpdate(const RSRenderNode & node)133 bool RSClipToBoundsDrawable::OnUpdate(const RSRenderNode& node)
134 {
135 const RSProperties& properties = node.GetRenderProperties();
136 RSPropertyDrawCmdListUpdater updater(0, 0, this);
137 auto& canvas = *updater.GetRecordingCanvas();
138 if (properties.GetClipBounds() != nullptr) {
139 canvas.ClipPath(properties.GetClipBounds()->GetDrawingPath(), Drawing::ClipOp::INTERSECT, true);
140 } else if (properties.GetClipToRRect()) {
141 canvas.ClipRoundRect(
142 RSPropertyDrawableUtils::RRect2DrawingRRect(properties.GetClipRRect()), Drawing::ClipOp::INTERSECT, true);
143 } else if (!properties.GetCornerRadius().IsZero()) {
144 canvas.ClipRoundRect(
145 RSPropertyDrawableUtils::RRect2DrawingRRect(properties.GetRRect()), Drawing::ClipOp::INTERSECT, true);
146 } else if (node.GetType() == RSRenderNodeType::SURFACE_NODE && RSSystemProperties::GetCacheEnabledForRotation() &&
147 node.ReinterpretCastTo<RSSurfaceRenderNode>()->IsAppWindow()) {
148 Drawing::Rect rect = RSPropertyDrawableUtils::Rect2DrawingRect(properties.GetBoundsRect());
149 Drawing::RectI iRect(rect.GetLeft(), rect.GetTop(), rect.GetRight(), rect.GetBottom());
150 canvas.ClipIRect(iRect, Drawing::ClipOp::INTERSECT);
151 } else {
152 canvas.ClipRect(
153 RSPropertyDrawableUtils::Rect2DrawingRect(properties.GetBoundsRect()), Drawing::ClipOp::INTERSECT, false);
154 }
155 return true;
156 }
157
OnGenerate(const RSRenderNode & node)158 RSDrawable::Ptr RSClipToFrameDrawable::OnGenerate(const RSRenderNode& node)
159 {
160 if (auto ret = std::make_shared<RSClipToFrameDrawable>(); ret->OnUpdate(node)) {
161 return std::move(ret);
162 }
163 return nullptr;
164 }
165
OnUpdate(const RSRenderNode & node)166 bool RSClipToFrameDrawable::OnUpdate(const RSRenderNode& node)
167 {
168 const RSProperties& properties = node.GetRenderProperties();
169 if (!properties.GetClipToFrame()) {
170 return false;
171 }
172
173 RSPropertyDrawCmdListUpdater updater(0, 0, this);
174 updater.GetRecordingCanvas()->ClipRect(
175 RSPropertyDrawableUtils::Rect2DrawingRect(properties.GetFrameRect()), Drawing::ClipOp::INTERSECT, false);
176 return true;
177 }
178
RSFilterDrawable()179 RSFilterDrawable::RSFilterDrawable()
180 {
181 if (RSProperties::filterCacheEnabled_) {
182 stagingCacheManager_ = std::make_unique<RSFilterCacheManager>();
183 cacheManager_ = std::make_unique<RSFilterCacheManager>();
184 }
185 }
186
PostUpdate(const RSRenderNode & node)187 void RSFilterDrawable::PostUpdate(const RSRenderNode& node)
188 {
189 if (!stagingFilter_ || !stagingFilter_->IsDrawingFilter()) {
190 return;
191 }
192 auto drawingFilter = std::static_pointer_cast<RSDrawingFilter>(stagingFilter_);
193 enableEDREffect_ = RSUIFilterHelper::CheckEnableEDR(drawingFilter->GetNGRenderFilter());
194 if (enableEDREffect_) {
195 screenNodeId_ = node.GetScreenNodeId();
196 }
197 }
198
OnSync()199 void RSFilterDrawable::OnSync()
200 {
201 if (needSync_) {
202 filter_ = std::move(stagingFilter_);
203 if (filter_) {
204 filter_->OnSync();
205 }
206 needSync_ = false;
207 }
208
209 renderNodeId_ = stagingNodeId_;
210 renderNodeName_ = stagingNodeName_;
211 renderIntersectWithDRM_ = stagingIntersectWithDRM_;
212 renderIsDarkColorMode_ = stagingIsDarkColorMode_;
213
214 stagingIntersectWithDRM_ = false;
215 stagingIsDarkColorMode_ = false;
216
217 needSync_ = false;
218
219 if (!RSProperties::filterCacheEnabled_ || stagingCacheManager_ == nullptr ||
220 cacheManager_ == nullptr || filter_ == nullptr) {
221 ROSEN_LOGD("Clear filter cache failed or no need to clear cache, filterCacheEnabled:%{public}d,"
222 "cacheManager:%{public}d, filter:%{public}d", RSProperties::filterCacheEnabled_,
223 stagingCacheManager_ != nullptr, filter_ == nullptr);
224 return;
225 }
226 stagingCacheManager_->SwapDataAndInitStagingFlags(cacheManager_);
227
228 if (filter_ && filter_->IsDrawingFilter() && enableEDREffect_) {
229 float displayHeadroom = RSEffectLuminanceManager::GetInstance().GetDisplayHeadroom(screenNodeId_);
230 auto filter = std::static_pointer_cast<RSDrawingFilter>(filter_);
231 filter->SetDisplayHeadroom(displayHeadroom);
232 }
233 }
234
WouldDrawLargeAreaBlur()235 bool RSFilterDrawable::WouldDrawLargeAreaBlur()
236 {
237 RS_TRACE_NAME_FMT("wouldDrawLargeAreaBlur stagingNodeId[%llu]", stagingNodeId_);
238 if (stagingCacheManager_ == nullptr) {
239 return false;
240 }
241 return stagingCacheManager_->WouldDrawLargeAreaBlur();
242 }
243
WouldDrawLargeAreaBlurPrecisely()244 bool RSFilterDrawable::WouldDrawLargeAreaBlurPrecisely()
245 {
246 RS_TRACE_NAME_FMT("wouldDrawLargeAreaBlurPrecisely stagingNodeId[%llu]", stagingNodeId_);
247 if (stagingCacheManager_ == nullptr) {
248 return false;
249 }
250 return stagingCacheManager_->WouldDrawLargeAreaBlurPrecisely();
251 }
252
CreateDrawFunc() const253 Drawing::RecordingCanvas::DrawFunc RSFilterDrawable::CreateDrawFunc() const
254 {
255 auto ptr = std::static_pointer_cast<const RSFilterDrawable>(shared_from_this());
256 return [ptr](Drawing::Canvas* canvas, const Drawing::Rect* rect) {
257 #ifdef RS_ENABLE_GPU
258 RSTagTracker tagTracker(canvas ? canvas->GetGPUContext() : nullptr,
259 RSTagTracker::SOURCETYPE::SOURCE_RSFILTERDRAWABLE);
260 #endif
261 if (ptr->needDrawBehindWindow_) {
262 if (!canvas->GetSurface()) {
263 RS_LOGE("RSFilterDrawable::CreateDrawFunc DrawBehindWindow surface is nullptr");
264 return;
265 }
266 auto paintFilterCanvas = static_cast<RSPaintFilterCanvas*>(canvas);
267 RS_TRACE_NAME_FMT("RSFilterDrawable::CreateDrawFunc DrawBehindWindow node[%" PRIu64 "], "
268 "windowFreezeCapture[%d], DrawingCache[%d]", ptr->renderNodeId_,
269 paintFilterCanvas->GetIsWindowFreezeCapture(), paintFilterCanvas->GetIsDrawingCache());
270 if (paintFilterCanvas->GetIsWindowFreezeCapture()) {
271 RS_LOGD("RSFilterDrawable::CreateDrawFunc DrawBehindWindow capture freeze surface, "
272 "no need to drawBehindWindow");
273 return;
274 }
275 Drawing::AutoCanvasRestore acr(*canvas, true);
276 paintFilterCanvas->ClipRect(*rect);
277 Drawing::Rect absRect(0.0, 0.0, 0.0, 0.0);
278 Drawing::Rect relativeBounds(ptr->drawBehindWindowRegion_.GetLeft(), ptr->drawBehindWindowRegion_.GetTop(),
279 ptr->drawBehindWindowRegion_.GetRight(), ptr->drawBehindWindowRegion_.GetBottom());
280 if (paintFilterCanvas->GetIsDrawingCache()) {
281 RS_OPTIONAL_TRACE_NAME_FMT("RSFilterDrawable::CreateDrawFunc DrawBehindWindow DrawingCache bounds:%s",
282 relativeBounds.ToString().c_str());
283 auto data = std::make_shared<RSPaintFilterCanvas::CacheBehindWindowData>(ptr->filter_, relativeBounds);
284 paintFilterCanvas->SetCacheBehindWindowData(std::move(data));
285 return;
286 }
287 canvas->GetTotalMatrix().MapRect(absRect, relativeBounds);
288 Drawing::RectI bounds(std::ceil(absRect.GetLeft()), std::ceil(absRect.GetTop()),
289 std::ceil(absRect.GetRight()), std::ceil(absRect.GetBottom()));
290 auto deviceRect = Drawing::RectI(0, 0, canvas->GetSurface()->Width(), canvas->GetSurface()->Height());
291 bounds.Intersect(deviceRect);
292 RSPropertyDrawableUtils::DrawBackgroundEffect(paintFilterCanvas, ptr->filter_, ptr->cacheManager_,
293 bounds, true);
294 return;
295 }
296 if (canvas && ptr && ptr->renderIntersectWithDRM_) {
297 RS_TRACE_NAME_FMT("RSFilterDrawable::CreateDrawFunc IntersectWithDRM node[%lld] isDarkColorMode[%d]",
298 ptr->renderNodeId_, ptr->renderIsDarkColorMode_);
299 RSPropertyDrawableUtils::DrawFilterWithDRM(canvas, ptr->renderIsDarkColorMode_);
300 return;
301 }
302 if (canvas && ptr && ptr->filter_) {
303 RS_TRACE_NAME_FMT("RSFilterDrawable::CreateDrawFunc node[%llu] ", ptr->renderNodeId_);
304 if (rect) {
305 auto filter = std::static_pointer_cast<RSDrawingFilter>(ptr->filter_);
306 filter->SetGeometry(*canvas, rect->GetWidth(), rect->GetHeight());
307 }
308 int64_t startBlurTime = Drawing::PerfmonitorReporter::GetCurrentTime();
309 RSPropertyDrawableUtils::DrawFilter(canvas, ptr->filter_,
310 ptr->cacheManager_, ptr->renderNodeId_, ptr->IsForeground());
311 int64_t blurDuration = Drawing::PerfmonitorReporter::GetCurrentTime() - startBlurTime;
312 auto filterType = ptr->filter_->GetFilterType();
313 RSPerfMonitorReporter::GetInstance().RecordBlurNode(ptr->renderNodeName_, blurDuration,
314 RSPropertyDrawableUtils::IsBlurFilterType(filterType));
315 if (rect != nullptr) {
316 RSPerfMonitorReporter::GetInstance().RecordBlurPerfEvent(ptr->renderNodeId_, ptr->renderNodeName_,
317 static_cast<uint16_t>(filterType), RSPropertyDrawableUtils::GetBlurFilterRadius(ptr->filter_),
318 rect->GetWidth(), rect->GetHeight(), blurDuration,
319 RSPropertyDrawableUtils::IsBlurFilterType(filterType));
320 }
321 }
322 };
323 }
324
GetFilterCachedRegion() const325 const RectI RSFilterDrawable::GetFilterCachedRegion() const
326 {
327 return cacheManager_ == nullptr ? RectI() : cacheManager_->GetCachedImageRegion();
328 }
329
MarkFilterRegionChanged()330 void RSFilterDrawable::MarkFilterRegionChanged()
331 {
332 if (stagingCacheManager_ == nullptr) {
333 return;
334 }
335 RSPerfMonitorReporter::GetInstance().RecordBlurCacheReason(this->renderNodeName_,
336 BLUR_CLEAR_CACHE_REASON::BLUR_REGION_CHANGED,
337 RSPropertyDrawableUtils::IsBlurFilterType(stagingCacheManager_->GetFilterType()));
338
339 stagingCacheManager_->MarkFilterRegionChanged();
340 }
341
MarkFilterRegionInteractWithDirty()342 void RSFilterDrawable::MarkFilterRegionInteractWithDirty()
343 {
344 if (stagingCacheManager_ == nullptr) {
345 return;
346 }
347 RSPerfMonitorReporter::GetInstance().RecordBlurCacheReason(this->renderNodeName_,
348 BLUR_CLEAR_CACHE_REASON::BLUR_CONTENT_CHANGED,
349 RSPropertyDrawableUtils::IsBlurFilterType(stagingCacheManager_->GetFilterType()));
350
351 stagingCacheManager_->MarkFilterRegionInteractWithDirty();
352 }
353
MarkFilterRegionIsLargeArea()354 void RSFilterDrawable::MarkFilterRegionIsLargeArea()
355 {
356 if (stagingCacheManager_ == nullptr) {
357 return;
358 }
359 RSPerfMonitorReporter::GetInstance().RecordBlurCacheReason(this->renderNodeName_,
360 BLUR_CLEAR_CACHE_REASON::DIRTY_OVER_SIZE,
361 RSPropertyDrawableUtils::IsBlurFilterType(stagingCacheManager_->GetFilterType()));
362
363 stagingCacheManager_->MarkFilterRegionIsLargeArea();
364 }
365
MarkFilterForceUseCache(bool forceUseCache)366 void RSFilterDrawable::MarkFilterForceUseCache(bool forceUseCache)
367 {
368 if (stagingCacheManager_ != nullptr) {
369 stagingCacheManager_->MarkFilterForceUseCache(forceUseCache);
370 }
371 }
372
MarkFilterForceClearCache()373 void RSFilterDrawable::MarkFilterForceClearCache()
374 {
375 if (stagingCacheManager_ == nullptr) {
376 return;
377 }
378 RSPerfMonitorReporter::GetInstance().RecordBlurCacheReason(this->renderNodeName_,
379 BLUR_CLEAR_CACHE_REASON::FORCE_CLEAR_CACHE,
380 RSPropertyDrawableUtils::IsBlurFilterType(stagingCacheManager_->GetFilterType()));
381 stagingCacheManager_->MarkFilterForceClearCache();
382 }
383
MarkRotationChanged()384 void RSFilterDrawable::MarkRotationChanged()
385 {
386 if (stagingCacheManager_ == nullptr) {
387 return;
388 }
389 RSPerfMonitorReporter::GetInstance().RecordBlurCacheReason(this->renderNodeName_,
390 BLUR_CLEAR_CACHE_REASON::ROTATION_CHANGED,
391 RSPropertyDrawableUtils::IsBlurFilterType(stagingCacheManager_->GetFilterType()));
392
393 stagingCacheManager_->MarkRotationChanged();
394 }
395
MarkNodeIsOccluded(bool isOccluded)396 void RSFilterDrawable::MarkNodeIsOccluded(bool isOccluded)
397 {
398 if (stagingCacheManager_ == nullptr) {
399 return;
400 }
401 RSPerfMonitorReporter::GetInstance().RecordBlurCacheReason(this->renderNodeName_,
402 BLUR_CLEAR_CACHE_REASON::NODE_IS_OCCLUDED,
403 RSPropertyDrawableUtils::IsBlurFilterType(stagingCacheManager_->GetFilterType()));
404
405 stagingCacheManager_->MarkNodeIsOccluded(isOccluded);
406 }
407
MarkForceClearCacheWithLastFrame()408 void RSFilterDrawable::MarkForceClearCacheWithLastFrame()
409 {
410 if (stagingCacheManager_ == nullptr) {
411 return;
412 }
413 RSPerfMonitorReporter::GetInstance().RecordBlurCacheReason(this->renderNodeName_,
414 BLUR_CLEAR_CACHE_REASON::SKIP_FRAME_NO_VSYNC,
415 RSPropertyDrawableUtils::IsBlurFilterType(stagingCacheManager_->GetFilterType()));
416
417 stagingCacheManager_->MarkForceClearCacheWithLastFrame();
418 }
419
MarkNeedClearFilterCache()420 void RSFilterDrawable::MarkNeedClearFilterCache()
421 {
422 if (stagingCacheManager_ == nullptr) {
423 return;
424 }
425 stagingCacheManager_->MarkNeedClearFilterCache(stagingNodeId_);
426 ROSEN_LOGD("RSFilterDrawable::MarkNeedClearFilterCache nodeId[%{public}lld]",
427 static_cast<long long>(stagingNodeId_));
428 }
429
430 //should be called in rs main thread
MarkBlurIntersectWithDRM(bool intersectWithDRM,bool isDark)431 void RSFilterDrawable::MarkBlurIntersectWithDRM(bool intersectWithDRM, bool isDark)
432 {
433 stagingIntersectWithDRM_ = intersectWithDRM;
434 stagingIsDarkColorMode_ = isDark;
435 }
436
MarkInForegroundFilterAndCheckNeedForceClearCache(NodeId offscreenCanvasNodeId)437 void RSFilterDrawable::MarkInForegroundFilterAndCheckNeedForceClearCache(NodeId offscreenCanvasNodeId)
438 {
439 if (stagingCacheManager_ == nullptr) {
440 return;
441 }
442 stagingCacheManager_->MarkInForegroundFilterAndCheckNeedForceClearCache(offscreenCanvasNodeId);
443 }
444
IsFilterCacheValid() const445 bool RSFilterDrawable::IsFilterCacheValid() const
446 {
447 if (stagingCacheManager_ == nullptr) {
448 return false;
449 }
450 return stagingCacheManager_->IsFilterCacheValid();
451 }
452
IsSkippingFrame() const453 bool RSFilterDrawable::IsSkippingFrame() const
454 {
455 if (stagingCacheManager_ == nullptr) {
456 return false;
457 }
458 return stagingCacheManager_->IsSkippingFrame();
459 }
460
IsForceClearFilterCache() const461 bool RSFilterDrawable::IsForceClearFilterCache() const
462 {
463 if (stagingCacheManager_ == nullptr) {
464 return false;
465 }
466 return stagingCacheManager_->IsForceClearFilterCache();
467 }
468
IsForceUseFilterCache() const469 bool RSFilterDrawable::IsForceUseFilterCache() const
470 {
471 if (stagingCacheManager_ == nullptr) {
472 return false;
473 }
474 return stagingCacheManager_->IsForceUseFilterCache();
475 }
476
NeedPendingPurge() const477 bool RSFilterDrawable::NeedPendingPurge() const
478 {
479 if (stagingCacheManager_ == nullptr) {
480 return false;
481 }
482 return stagingCacheManager_->NeedPendingPurge();
483 }
484
MarkEffectNode()485 void RSFilterDrawable::MarkEffectNode()
486 {
487 if (stagingCacheManager_ != nullptr) {
488 stagingCacheManager_->MarkEffectNode();
489 }
490 }
491
RecordFilterInfos(const std::shared_ptr<RSFilter> & rsFilter)492 void RSFilterDrawable::RecordFilterInfos(const std::shared_ptr<RSFilter>& rsFilter)
493 {
494 if (stagingCacheManager_ != nullptr) {
495 stagingCacheManager_->RecordFilterInfos(rsFilter);
496 }
497 }
498
499 // called after OnSync()
IsFilterCacheValidForOcclusion()500 bool RSFilterDrawable::IsFilterCacheValidForOcclusion()
501 {
502 if (cacheManager_ == nullptr) {
503 ROSEN_LOGD("RSFilterDrawable::IsFilterCacheValidForOcclusion cacheManager not available");
504 return false;
505 }
506 return cacheManager_->IsFilterCacheValidForOcclusion();
507 }
508
IsAIBarFilter() const509 bool RSFilterDrawable::IsAIBarFilter() const
510 {
511 if (stagingCacheManager_ == nullptr) {
512 return false;
513 }
514 return stagingCacheManager_->GetFilterType() == RSFilter::AIBAR;
515 }
516
CheckAndUpdateAIBarCacheStatus(bool intersectHwcDamage)517 bool RSFilterDrawable::CheckAndUpdateAIBarCacheStatus(bool intersectHwcDamage)
518 {
519 if (stagingCacheManager_ == nullptr) {
520 return false;
521 }
522 return stagingCacheManager_->CheckAndUpdateAIBarCacheStatus(intersectHwcDamage);
523 }
524
SetDrawBehindWindowRegion(RectI region)525 void RSFilterDrawable::SetDrawBehindWindowRegion(RectI region)
526 {
527 stagingDrawBehindWindowRegion_ = region;
528 }
529
530 } // namespace DrawableV2
531 } // namespace OHOS::Rosen
532