1 /*
2 * Copyright (c) 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_base_render_engine.h"
17 #include <memory>
18
19 #ifdef RS_ENABLE_EGLIMAGE
20 #include "src/gpu/gl/GrGLDefines.h"
21 #endif
22
23 #include "rs_divided_render_util.h"
24 #include "common/rs_optional_trace.h"
25 #include "memory/rs_tag_tracker.h"
26 #include "pipeline/rs_uni_render_judgement.h"
27 #include "platform/common/rs_log.h"
28 #include "platform/common/rs_system_properties.h"
29 #if defined(NEW_RENDER_CONTEXT)
30 #include "render_context_factory.h"
31 #include "rs_surface_factory.h"
32 #include "ohos/rs_render_surface_ohos.h"
33 #else
34 #include "platform/ohos/backend/rs_surface_ohos_gl.h"
35 #include "platform/ohos/backend/rs_surface_ohos_raster.h"
36 #ifdef RS_ENABLE_VK
37 #include "platform/ohos/backend/rs_vulkan_context.h"
38 #include "platform/ohos/backend/rs_surface_ohos_vulkan.h"
39 #endif
40 #endif
41 #include "render/rs_drawing_filter.h"
42 #include "render/rs_skia_filter.h"
43 #include "metadata_helper.h"
44
45 #include "drawable/rs_display_render_node_drawable.h"
46
47 namespace OHOS {
48 namespace Rosen {
RSBaseRenderEngine()49 RSBaseRenderEngine::RSBaseRenderEngine()
50 {
51 }
52
~RSBaseRenderEngine()53 RSBaseRenderEngine::~RSBaseRenderEngine() noexcept
54 {
55 }
56
Init(bool independentContext)57 void RSBaseRenderEngine::Init(bool independentContext)
58 {
59 (void)independentContext;
60 #if defined(NEW_RENDER_CONTEXT)
61 RenderType renderType = RenderType::RASTER;
62 #if (defined RS_ENABLE_GL) || (defined RS_ENABLE_VK)
63 if (OHOS::Rosen::RSSystemProperties::GetGpuApiType() == OHOS::Rosen::GpuApiType::OPENGL) {
64 renderType = RenderType::GLES;
65 } else if (RSSystemProperties::IsUseVulkan()) {
66 renderType = RenderType::VULKAN;
67 }
68 #endif
69 renderContext_ = RenderContextBaseFactory::CreateRenderContext(renderType);
70 renderContext_->Init();
71 drawingContext_ = std::make_shared<Rosen::DrawingContext>(renderContext_->GetRenderType());
72 drawingContext_->SetUpDrawingContext();
73 #else
74 #if (defined RS_ENABLE_GL) || (defined RS_ENABLE_VK)
75 renderContext_ = std::make_shared<RenderContext>();
76 #ifdef RS_ENABLE_GL
77 if (!RSSystemProperties::IsUseVulkan()) {
78 renderContext_->InitializeEglContext();
79 }
80 #endif
81 if (RSUniRenderJudgement::IsUniRender()) {
82 RS_LOGI("RSRenderEngine::RSRenderEngine set new cacheDir");
83 renderContext_->SetUniRenderMode(true);
84 }
85 #if defined(RS_ENABLE_VK)
86 if (RSSystemProperties::IsUseVulkan()) {
87 skContext_ = RsVulkanContext::GetSingleton().CreateDrawingContext(independentContext);
88 vkImageManager_ = std::make_shared<RSVkImageManager>();
89 renderContext_->SetUpGpuContext(skContext_);
90 } else {
91 renderContext_->SetUpGpuContext();
92 }
93 #else
94 renderContext_->SetUpGpuContext();
95 #endif
96 #endif // RS_ENABLE_GL || RS_ENABLE_VK
97 #endif
98 #if defined(RS_ENABLE_EGLIMAGE)
99 #if defined(NEW_RENDER_CONTEXT)
100 std::shared_ptr<RSRenderSurfaceFrame> frame = renderContext_->GetRSRenderSurfaceFrame();
101 eglImageManager_ = std::make_shared<RSEglImageManager>(frame->eglState->eglDisplay);
102 #else
103 eglImageManager_ = std::make_shared<RSEglImageManager>(renderContext_->GetEGLDisplay());
104 #endif
105 #endif // RS_ENABLE_EGLIMAGE
106 #ifdef RS_ENABLE_VK
107 if (RSSystemProperties::IsUseVulkan()) {
108 skContext_ = RsVulkanContext::GetSingleton().CreateDrawingContext();
109 vkImageManager_ = std::make_shared<RSVkImageManager>();
110 }
111 #endif
112 #ifdef USE_VIDEO_PROCESSING_ENGINE
113 colorSpaceConverterDisplay_ = Media::VideoProcessingEngine::ColorSpaceConverterDisplay::Create();
114 #endif
115 }
116
InitCapture(bool independentContext)117 void RSBaseRenderEngine::InitCapture(bool independentContext)
118 {
119 (void)independentContext;
120 if (captureRenderContext_) {
121 return;
122 }
123
124 #if (defined RS_ENABLE_GL) || (defined RS_ENABLE_VK)
125 captureRenderContext_ = std::make_shared<RenderContext>();
126 #ifdef RS_ENABLE_GL
127 if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
128 captureRenderContext_->InitializeEglContext();
129 }
130 #endif
131 if (RSUniRenderJudgement::IsUniRender()) {
132 captureRenderContext_->SetUniRenderMode(true);
133 }
134 #if defined(RS_ENABLE_VK)
135 if (RSSystemProperties::IsUseVulkan()) {
136 captureSkContext_ = RsVulkanContext::GetSingleton().CreateDrawingContext(independentContext);
137 captureRenderContext_->SetUpGpuContext(captureSkContext_);
138 } else {
139 captureRenderContext_->SetUpGpuContext();
140 }
141 #else
142 captureRenderContext_->SetUpGpuContext();
143 #endif
144 #endif // RS_ENABLE_GL || RS_ENABLE_VK
145 }
146
ResetCurrentContext()147 void RSBaseRenderEngine::ResetCurrentContext()
148 {
149 if (renderContext_ == nullptr) {
150 RS_LOGE("This render context is nullptr.");
151 return;
152 }
153 #if (defined RS_ENABLE_GL)
154 if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
155 renderContext_->ShareMakeCurrentNoSurface(EGL_NO_CONTEXT);
156 if (captureRenderContext_) {
157 captureRenderContext_->ShareMakeCurrentNoSurface(EGL_NO_CONTEXT);
158 }
159 }
160 #endif
161
162 #if defined(RS_ENABLE_VK) // end RS_ENABLE_GL and enter RS_ENABLE_VK
163 if (RSSystemProperties::IsUseVulkan()) {
164 renderContext_->AbandonContext();
165 if (captureRenderContext_) {
166 captureRenderContext_->AbandonContext();
167 }
168 }
169 #endif // end RS_ENABLE_GL and RS_ENABLE_VK
170 }
171
NeedForceCPU(const std::vector<LayerInfoPtr> & layers)172 bool RSBaseRenderEngine::NeedForceCPU(const std::vector<LayerInfoPtr>& layers)
173 {
174 bool forceCPU = false;
175 for (const auto& layer: layers) {
176 if (layer == nullptr) {
177 continue;
178 }
179
180 auto buffer = layer->GetBuffer();
181 if (buffer == nullptr) {
182 continue;
183 }
184
185 #ifndef RS_ENABLE_EGLIMAGE
186 const auto bufferFormat = buffer->GetFormat();
187 if (bufferFormat == GRAPHIC_PIXEL_FMT_YCRCB_420_SP || bufferFormat == GRAPHIC_PIXEL_FMT_YCBCR_420_SP) {
188 forceCPU = true;
189 break;
190 }
191 #endif
192 }
193
194 return forceCPU;
195 }
196
CreateEglImageFromBuffer(RSPaintFilterCanvas & canvas,const sptr<SurfaceBuffer> & buffer,const sptr<SyncFence> & acquireFence,const uint32_t threadIndex,const std::shared_ptr<Drawing::ColorSpace> & drawingColorSpace)197 std::shared_ptr<Drawing::Image> RSBaseRenderEngine::CreateEglImageFromBuffer(RSPaintFilterCanvas& canvas,
198 const sptr<SurfaceBuffer>& buffer, const sptr<SyncFence>& acquireFence, const uint32_t threadIndex,
199 const std::shared_ptr<Drawing::ColorSpace>& drawingColorSpace)
200 {
201 #ifdef RS_ENABLE_EGLIMAGE
202 #if defined(RS_ENABLE_GL)
203 if (!RSSystemProperties::IsUseVulkan() && canvas.GetGPUContext() == nullptr) {
204 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer GrContext is null!");
205 return nullptr;
206 }
207 #endif // RS_ENABLE_GL
208 #if defined(RS_ENABLE_VK)
209 if (RSSystemProperties::IsUseVulkan() && renderContext_->GetDrGPUContext() == nullptr) {
210 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer GrContext is null!");
211 return nullptr;
212 }
213 #endif // RS_ENABLE_VK
214 auto eglTextureId = eglImageManager_->MapEglImageFromSurfaceBuffer(buffer, acquireFence, threadIndex);
215 if (eglTextureId == 0) {
216 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer MapEglImageFromSurfaceBuffer return invalid texture ID");
217 return nullptr;
218 }
219 auto pixelFmt = buffer->GetFormat();
220 auto bitmapFormat = RSBaseRenderUtil::GenerateDrawingBitmapFormat(buffer);
221
222 auto image = std::make_shared<Drawing::Image>();
223 Drawing::TextureInfo externalTextureInfo;
224 externalTextureInfo.SetWidth(buffer->GetSurfaceBufferWidth());
225 externalTextureInfo.SetHeight(buffer->GetSurfaceBufferHeight());
226
227 #ifndef ROSEN_EMULATOR
228 auto surfaceOrigin = Drawing::TextureOrigin::TOP_LEFT;
229 #else
230 auto surfaceOrigin = Drawing::TextureOrigin::BOTTOM_LEFT;
231 #endif
232
233 #if defined(RS_ENABLE_GL)
234 if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
235 externalTextureInfo.SetIsMipMapped(false);
236 externalTextureInfo.SetTarget(GL_TEXTURE_EXTERNAL_OES);
237 externalTextureInfo.SetID(eglTextureId);
238 auto glType = GR_GL_RGBA8;
239 if (pixelFmt == GRAPHIC_PIXEL_FMT_BGRA_8888) {
240 glType = GR_GL_BGRA8;
241 } else if (pixelFmt == GRAPHIC_PIXEL_FMT_YCBCR_P010 || pixelFmt == GRAPHIC_PIXEL_FMT_YCRCB_P010 ||
242 pixelFmt == GRAPHIC_PIXEL_FMT_RGBA_1010102) {
243 glType = GR_GL_RGB10_A2;
244 }
245 externalTextureInfo.SetFormat(glType);
246 if (!image->BuildFromTexture(*canvas.GetGPUContext(), externalTextureInfo,
247 surfaceOrigin, bitmapFormat, drawingColorSpace)) {
248 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer image BuildFromTexture failed");
249 return nullptr;
250 }
251 }
252 #endif
253
254 #if defined(RS_ENABLE_VK)
255 if (RSSystemProperties::IsUseVulkan() &&
256 !image->BuildFromTexture(*renderContext_->GetDrGPUContext(), externalTextureInfo,
257 surfaceOrigin, bitmapFormat, drawingColorSpace)) {
258 RS_LOGE("RSBaseRenderEngine::CreateEglImageFromBuffer image BuildFromTexture failed");
259 return nullptr;
260 }
261 #endif
262 return image;
263 #else
264 return nullptr;
265 #endif // RS_ENABLE_EGLIMAGE
266 }
267
268 #ifdef NEW_RENDER_CONTEXT
RequestFrame(const std::shared_ptr<RSRenderSurfaceOhos> & rsSurface,const BufferRequestConfig & config,bool forceCPU,bool useAFBC,const FrameContextConfig & frameContextConfig)269 std::unique_ptr<RSRenderFrame> RSBaseRenderEngine::RequestFrame(
270 const std::shared_ptr<RSRenderSurfaceOhos>& rsSurface,
271 const BufferRequestConfig& config, bool forceCPU, bool useAFBC,
272 const FrameContextConfig& frameContextConfig)
273 #else
274 std::unique_ptr<RSRenderFrame> RSBaseRenderEngine::RequestFrame(
275 const std::shared_ptr<RSSurfaceOhos>& rsSurface,
276 const BufferRequestConfig& config, bool forceCPU, bool useAFBC,
277 const FrameContextConfig& frameContextConfig)
278 #endif
279 {
280 #ifdef RS_ENABLE_VK
281 if (RSSystemProperties::GetGpuApiType() == GpuApiType::VULKAN ||
282 RSSystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
283 skContext_ = RsVulkanContext::GetSingleton().CreateDrawingContext(
284 frameContextConfig.independentContext);
285 if (renderContext_ == nullptr) {
286 return nullptr;
287 }
288 renderContext_->SetUpGpuContext(skContext_);
289 }
290 #endif
291 if (rsSurface == nullptr) {
292 RS_LOGE("RSBaseRenderEngine::RequestFrame: surface is null!");
293 return nullptr;
294 }
295 RS_OPTIONAL_TRACE_BEGIN("RSBaseRenderEngine::RequestFrame(RSSurface)");
296 #ifdef RS_ENABLE_VK
297 RSTagTracker tagTracker(skContext_.get(), RSTagTracker::TAGTYPE::TAG_ACQUIRE_SURFACE);
298 #endif
299 rsSurface->SetColorSpace(config.colorGamut);
300 rsSurface->SetSurfacePixelFormat(config.format);
301 if (frameContextConfig.isVirtual) {
302 RS_LOGD("RSBaseRenderEngine::RequestFrame: Mirror Screen Set Timeout to 0.");
303 rsSurface->SetTimeOut(frameContextConfig.timeOut);
304 }
305 auto bufferUsage = config.usage;
306 #if (defined(RS_ENABLE_GL) || defined(RS_ENABLE_VK)) && (defined RS_ENABLE_EGLIMAGE)
307 if (forceCPU) {
308 bufferUsage |= BUFFER_USAGE_CPU_WRITE;
309 }
310 #else
311 bufferUsage |= BUFFER_USAGE_CPU_WRITE;
312 #endif
313 if (frameContextConfig.isProtected) {
314 bufferUsage |= BUFFER_USAGE_PROTECTED;
315 }
316 rsSurface->SetSurfaceBufferUsage(bufferUsage);
317
318 // check if we can use GPU context
319 #if defined(NEW_RENDER_CONTEXT)
320 #if defined(RS_ENABLE_GL) || defined(RS_ENABLE_VK)
321 if (forceCPU) {
322 std::shared_ptr<RenderContextBase> renderContextRaster = RenderContextBaseFactory::CreateRenderContext(
323 RenderType::RASTER);
324 renderContextRaster->Init();
325 std::shared_ptr<DrawingContext> drawingContextRaster = std::make_shared<DrawingContext>(RenderType::RASTER);
326 rsSurface->SetRenderContext(renderContextRaster);
327 rsSurface->SetDrawingContext(drawingContextRaster);
328 RS_LOGD("RSBaseRenderEngine::RequestFrame force CPU");
329 } else {
330 if (renderContext_ != nullptr) {
331 rsSurface->SetRenderContext(renderContext_);
332 }
333 if (drawingContext_ != nullptr) {
334 rsSurface->SetDrawingContext(drawingContext_);
335 }
336 }
337 #endif
338 #else
339 #ifdef RS_ENABLE_GL
340 if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL &&
341 renderContext_ != nullptr) {
342 rsSurface->SetRenderContext(renderContext_.get());
343 }
344 #endif
345 #ifdef RS_ENABLE_VK
346 if (RSSystemProperties::IsUseVulkan() && skContext_ != nullptr) {
347 std::static_pointer_cast<RSSurfaceOhosVulkan>(rsSurface)->SetSkContext(skContext_);
348 }
349 #endif
350 #endif
351 auto surfaceFrame = rsSurface->RequestFrame(config.width, config.height, 0, useAFBC,
352 frameContextConfig.isProtected);
353 RS_OPTIONAL_TRACE_END();
354 if (surfaceFrame == nullptr) {
355 RS_LOGE("RSBaseRenderEngine::RequestFrame: request SurfaceFrame failed!");
356 return nullptr;
357 }
358 #ifdef NEW_RENDER_CONTEXT
359 return std::make_unique<RSRenderFrame>(rsSurface);
360 #else
361 return std::make_unique<RSRenderFrame>(rsSurface, std::move(surfaceFrame));
362 #endif
363 }
364
RequestFrame(const sptr<Surface> & targetSurface,const BufferRequestConfig & config,bool forceCPU,bool useAFBC,const FrameContextConfig & frameContextConfig)365 std::unique_ptr<RSRenderFrame> RSBaseRenderEngine::RequestFrame(const sptr<Surface>& targetSurface,
366 const BufferRequestConfig& config, bool forceCPU, bool useAFBC,
367 const FrameContextConfig& frameContextConfig)
368 {
369 RS_OPTIONAL_TRACE_BEGIN("RSBaseRenderEngine::RequestFrame(targetSurface)");
370 if (targetSurface == nullptr) {
371 RS_LOGE("RSBaseRenderEngine::RequestFrame: surface is null!");
372 RS_OPTIONAL_TRACE_END();
373 return nullptr;
374 }
375
376 #if defined(NEW_RENDER_CONTEXT)
377 std::shared_ptr<RSRenderSurfaceOhos> rsSurface = nullptr;
378 std::shared_ptr<RSRenderSurface> renderSurface = RSSurfaceFactory::CreateRSSurface(PlatformName::OHOS,
379 targetSurface);
380 rsSurface = std::static_pointer_cast<RSRenderSurfaceOhos>(renderSurface);
381 #else
382 std::shared_ptr<RSSurfaceOhos> rsSurface = nullptr;
383 #if (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE)
384 if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
385 if (forceCPU) {
386 rsSurface = std::make_shared<RSSurfaceOhosRaster>(targetSurface);
387 } else {
388 rsSurface = std::make_shared<RSSurfaceOhosGl>(targetSurface);
389 }
390 }
391 #endif
392 #if (defined RS_ENABLE_VK)
393 if (RSSystemProperties::IsUseVulkan()) {
394 rsSurface = std::make_shared<RSSurfaceOhosVulkan>(targetSurface);
395 }
396 #endif
397 if (rsSurface == nullptr) {
398 rsSurface = std::make_shared<RSSurfaceOhosRaster>(targetSurface);
399 }
400 #endif
401 RS_OPTIONAL_TRACE_END();
402 return RequestFrame(rsSurface, config, forceCPU, useAFBC, frameContextConfig);
403 }
404
405 #ifdef NEW_RENDER_CONTEXT
MakeRSSurface(const sptr<Surface> & targetSurface,bool forceCPU)406 std::shared_ptr<RSRenderSurfaceOhos> RSBaseRenderEngine::MakeRSSurface(const sptr<Surface>& targetSurface,
407 bool forceCPU)
408 #else
409 std::shared_ptr<RSSurfaceOhos> RSBaseRenderEngine::MakeRSSurface(const sptr<Surface>& targetSurface, bool forceCPU)
410 #endif
411 {
412 RS_TRACE_FUNC();
413 if (targetSurface == nullptr) {
414 RS_LOGE("RSBaseRenderEngine::MakeRSSurface: surface is null!");
415 RS_OPTIONAL_TRACE_END();
416 return nullptr;
417 }
418
419 #if defined(NEW_RENDER_CONTEXT)
420 std::shared_ptr<RSRenderSurfaceOhos> rsSurface = nullptr;
421 std::shared_ptr<RSRenderSurface> renderSurface = RSSurfaceFactory::CreateRSSurface(PlatformName::OHOS,
422 targetSurface);
423 rsSurface = std::static_pointer_cast<RSRenderSurfaceOhos>(renderSurface);
424 #else
425 std::shared_ptr<RSSurfaceOhos> rsSurface = nullptr;
426 #if (defined RS_ENABLE_GL) && (defined RS_ENABLE_EGLIMAGE)
427 if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
428 if (forceCPU) {
429 rsSurface = std::make_shared<RSSurfaceOhosRaster>(targetSurface);
430 } else {
431 rsSurface = std::make_shared<RSSurfaceOhosGl>(targetSurface);
432 }
433 }
434 #endif
435 #if (defined RS_ENABLE_VK)
436 if (RSSystemProperties::IsUseVulkan()) {
437 rsSurface = std::make_shared<RSSurfaceOhosVulkan>(targetSurface);
438 }
439 #endif
440 if (rsSurface == nullptr) {
441 rsSurface = std::make_shared<RSSurfaceOhosRaster>(targetSurface);
442 }
443 #endif
444 return rsSurface;
445 }
446
447 #ifdef NEW_RENDER_CONTEXT
SetUiTimeStamp(const std::unique_ptr<RSRenderFrame> & renderFrame,std::shared_ptr<RSRenderSurfaceOhos> surfaceOhos)448 void RSBaseRenderEngine::SetUiTimeStamp(const std::unique_ptr<RSRenderFrame>& renderFrame,
449 std::shared_ptr<RSRenderSurfaceOhos> surfaceOhos)
450 #else
451 void RSBaseRenderEngine::SetUiTimeStamp(const std::unique_ptr<RSRenderFrame>& renderFrame,
452 std::shared_ptr<RSSurfaceOhos> surfaceOhos)
453 #endif
454 {
455 if (surfaceOhos == nullptr) {
456 RS_LOGE("RSBaseRenderEngine::SetUiTimeStamp: surfaceOhos is null!");
457 return;
458 }
459
460 if (renderFrame == nullptr) {
461 RS_LOGE("RSBaseRenderEngine::SetUiTimeStamp: renderFrame is null!.");
462 return;
463 }
464
465 #ifdef NEW_RENDER_CONTEXT
466 surfaceOhos->SetUiTimeStamp();
467 #else
468 auto& frame = renderFrame->GetFrame();
469 surfaceOhos->SetUiTimeStamp(frame);
470 #endif
471 }
472
DrawDisplayNodeWithParams(RSPaintFilterCanvas & canvas,RSDisplayRenderNode & node,BufferDrawParam & params)473 void RSBaseRenderEngine::DrawDisplayNodeWithParams(RSPaintFilterCanvas& canvas, RSDisplayRenderNode& node,
474 BufferDrawParam& params)
475 {
476 if (params.useCPU) {
477 DrawBuffer(canvas, params);
478 } else {
479 auto drawable = node.GetRenderDrawable();
480 if (!drawable) {
481 return;
482 }
483 auto displayDrawable = std::static_pointer_cast<DrawableV2::RSDisplayRenderNodeDrawable>(drawable);
484 RegisterDeleteBufferListener(displayDrawable->GetRSSurfaceHandlerOnDraw()->GetConsumer());
485 DrawImage(canvas, params);
486 }
487 }
488
DrawDisplayNodeWithParams(RSPaintFilterCanvas & canvas,RSSurfaceHandler & surfaceHandler,BufferDrawParam & drawParam)489 void RSBaseRenderEngine::DrawDisplayNodeWithParams(RSPaintFilterCanvas& canvas, RSSurfaceHandler& surfaceHandler,
490 BufferDrawParam& drawParam)
491 {
492 if (drawParam.useCPU) {
493 DrawBuffer(canvas, drawParam);
494 } else {
495 RegisterDeleteBufferListener(surfaceHandler.GetConsumer());
496 DrawImage(canvas, drawParam);
497 }
498 }
499
SetColorFilterMode(ColorFilterMode mode)500 void RSBaseRenderEngine::SetColorFilterMode(ColorFilterMode mode)
501 {
502 std::lock_guard<std::mutex> lock(colorFilterMutex_);
503 uint32_t uMode = static_cast<uint32_t>(mode);
504 uint32_t uInvertMode = static_cast<uint32_t>(ColorFilterMode::INVERT_COLOR_ENABLE_MODE);
505 uint32_t ucolorFilterMode = static_cast<uint32_t>(colorFilterMode_);
506 bool isInvertModeEnabled = ((ucolorFilterMode & uInvertMode) == uInvertMode);
507
508 switch (mode) {
509 case ColorFilterMode::INVERT_COLOR_DISABLE_MODE: {
510 if (colorFilterMode_ != ColorFilterMode::COLOR_FILTER_END) {
511 colorFilterMode_ = static_cast<ColorFilterMode>(ucolorFilterMode & ~uInvertMode);
512 }
513 break;
514 }
515 case ColorFilterMode::INVERT_COLOR_ENABLE_MODE: {
516 if (colorFilterMode_ != ColorFilterMode::COLOR_FILTER_END) {
517 colorFilterMode_ = static_cast<ColorFilterMode>(ucolorFilterMode | uInvertMode);
518 } else {
519 colorFilterMode_ = mode;
520 }
521 break;
522 }
523 case ColorFilterMode::DALTONIZATION_PROTANOMALY_MODE:
524 case ColorFilterMode::DALTONIZATION_DEUTERANOMALY_MODE:
525 case ColorFilterMode::DALTONIZATION_TRITANOMALY_MODE: {
526 if (isInvertModeEnabled) {
527 colorFilterMode_ = static_cast<ColorFilterMode>(uMode | uInvertMode);
528 } else {
529 colorFilterMode_ = mode;
530 }
531 break;
532 }
533 case ColorFilterMode::DALTONIZATION_NORMAL_MODE: {
534 if (isInvertModeEnabled) {
535 colorFilterMode_ = ColorFilterMode::INVERT_COLOR_ENABLE_MODE;
536 } else {
537 colorFilterMode_ = ColorFilterMode::COLOR_FILTER_END;
538 }
539 break;
540 }
541
542 // INVERT_DALTONIZATION_PROTANOMALY_MODE, INVERT_DALTONIZATION_DEUTERANOMALY_MODE
543 // INVERT_DALTONIZATION_TRITANOMALY_MODE and COLOR_FILTER_END can not be set directly
544 case ColorFilterMode::INVERT_DALTONIZATION_PROTANOMALY_MODE: // fall-through
545 case ColorFilterMode::INVERT_DALTONIZATION_DEUTERANOMALY_MODE: // fall-through
546 case ColorFilterMode::INVERT_DALTONIZATION_TRITANOMALY_MODE: // fall-through
547 case ColorFilterMode::COLOR_FILTER_END: // fall-through
548 default: {
549 colorFilterMode_ = ColorFilterMode::COLOR_FILTER_END;
550 break;
551 }
552 }
553 }
554
GetColorFilterMode()555 ColorFilterMode RSBaseRenderEngine::GetColorFilterMode()
556 {
557 std::lock_guard<std::mutex> lock(colorFilterMutex_);
558 return colorFilterMode_;
559 }
560
SetHighContrast(bool enabled)561 void RSBaseRenderEngine::SetHighContrast(bool enabled)
562 {
563 isHighContrastEnabled_ = enabled;
564 }
565
IsHighContrastEnabled()566 bool RSBaseRenderEngine::IsHighContrastEnabled()
567 {
568 return isHighContrastEnabled_;
569 }
570
DrawBuffer(RSPaintFilterCanvas & canvas,BufferDrawParam & params)571 void RSBaseRenderEngine::DrawBuffer(RSPaintFilterCanvas& canvas, BufferDrawParam& params)
572 {
573 RS_TRACE_NAME("RSBaseRenderEngine::DrawBuffer(CPU)");
574 Drawing::Bitmap bitmap;
575 std::vector<uint8_t> newBuffer;
576 if (!RSBaseRenderUtil::ConvertBufferToBitmap(params.buffer, newBuffer, params.targetColorGamut, bitmap,
577 params.metaDatas)) {
578 RS_LOGE("RSDividedRenderUtil::DrawBuffer: create bitmap failed.");
579 return;
580 }
581 Drawing::Image drImage;
582 drImage.BuildFromBitmap(bitmap);
583 canvas.DrawImageRect(drImage, params.srcRect, params.dstRect, Drawing::SamplingOptions(),
584 Drawing::SrcRectConstraint::STRICT_SRC_RECT_CONSTRAINT);
585 }
586
587 #ifdef USE_VIDEO_PROCESSING_ENGINE
ConvertDrawingColorSpaceToSpaceInfo(const std::shared_ptr<Drawing::ColorSpace> & colorSpace,HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceInfo & colorSpaceInfo)588 bool RSBaseRenderEngine::ConvertDrawingColorSpaceToSpaceInfo(const std::shared_ptr<Drawing::ColorSpace>& colorSpace,
589 HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceInfo& colorSpaceInfo)
590 {
591 using namespace HDI::Display::Graphic::Common::V1_0;
592 CM_ColorSpaceType colorSpaceType = CM_COLORSPACE_NONE;
593 if (colorSpace == nullptr || colorSpace->Equals(nullptr) || colorSpace->IsSRGB()) {
594 colorSpaceType = CM_SRGB_FULL;
595 } else if (colorSpace->Equals(Drawing::ColorSpace::CreateRGB(
596 Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::DCIP3))) {
597 colorSpaceType = CM_P3_FULL;
598 } else if (colorSpace->Equals(Drawing::ColorSpace::CreateRGB(
599 Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::ADOBE_RGB))) {
600 colorSpaceType = CM_ADOBERGB_FULL;
601 } else if (colorSpace->Equals(Drawing::ColorSpace::CreateRGB(
602 Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::REC2020))) {
603 colorSpaceType = CM_DISPLAY_BT2020_SRGB;
604 } else {
605 RS_LOGD("RSBaseRenderEngine::ConvertDrawingColorSpaceToSpaceInfo color space not supported");
606 return false;
607 }
608
609 GSError ret = MetadataHelper::ConvertColorSpaceTypeToInfo(colorSpaceType, colorSpaceInfo);
610 if (ret != GSERROR_OK) {
611 RS_LOGE("RSBaseRenderEngine::ConvertDrawingColorSpaceToSpaceInfo ConvertColorSpaceTypeToInfo failed with \
612 %{public}u.", ret);
613 return false;
614 }
615
616 return true;
617 }
618
GetCanvasColorSpace(const RSPaintFilterCanvas & canvas)619 std::shared_ptr<Drawing::ColorSpace> RSBaseRenderEngine::GetCanvasColorSpace(const RSPaintFilterCanvas& canvas)
620 {
621 auto surface = canvas.GetSurface();
622 if (surface == nullptr) {
623 return nullptr;
624 }
625
626 return surface->GetImageInfo().GetColorSpace();
627 }
628
SetColorSpaceConverterDisplayParameter(const BufferDrawParam & params,Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter & parameter)629 bool RSBaseRenderEngine::SetColorSpaceConverterDisplayParameter(
630 const BufferDrawParam& params, Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter& parameter)
631 {
632 using namespace HDI::Display::Graphic::Common::V1_0;
633
634 CM_HDR_Metadata_Type hdrMetadataType = CM_METADATA_NONE;
635 GSError ret = MetadataHelper::GetHDRMetadataType(params.buffer, hdrMetadataType);
636 if (ret != GSERROR_OK) {
637 RS_LOGD("RSBaseRenderEngine::ColorSpaceConvertor GetHDRMetadataType failed with %{public}u.", ret);
638 }
639
640 parameter.inputColorSpace.metadataType = hdrMetadataType;
641 parameter.outputColorSpace.metadataType = hdrMetadataType;
642
643 ret = MetadataHelper::GetHDRStaticMetadata(params.buffer, parameter.staticMetadata);
644 if (ret != GSERROR_OK) {
645 RS_LOGD("RSBaseRenderEngine::ColorSpaceConvertor GetHDRStaticMetadata failed with %{public}u.", ret);
646 }
647 ret = MetadataHelper::GetHDRDynamicMetadata(params.buffer, parameter.dynamicMetadata);
648 if (ret != GSERROR_OK) {
649 RS_LOGD("RSBaseRenderEngine::ColorSpaceConvertor GetHDRDynamicMetadata failed with %{public}u.", ret);
650 }
651
652 parameter.width = params.buffer->GetWidth();
653 parameter.height = params.buffer->GetHeight();
654 parameter.tmoNits = params.tmoNits;
655 parameter.currentDisplayNits = params.displayNits;
656 parameter.sdrNits = params.sdrNits;
657
658 RS_LOGD("RSBaseRenderEngine::ColorSpaceConvertor parameter inputColorSpace.colorSpaceInfo.primaries = %{public}u, \
659 inputColorSpace.metadataType = %{public}u, outputColorSpace.colorSpaceInfo.primaries = %{public}u, \
660 outputColorSpace.metadataType = %{public}u, tmoNits = %{public}f, currentDisplayNits = %{public}f, \
661 sdrNits = %{public}f",
662 parameter.inputColorSpace.colorSpaceInfo.primaries, parameter.inputColorSpace.metadataType,
663 parameter.outputColorSpace.colorSpaceInfo.primaries, parameter.outputColorSpace.metadataType,
664 parameter.tmoNits, parameter.currentDisplayNits, paramter.sdrNits);
665
666 return true;
667 }
668
ConvertColorGamutToDrawingColorSpace(GraphicColorGamut colorGamut)669 std::shared_ptr<Drawing::ColorSpace> RSBaseRenderEngine::ConvertColorGamutToDrawingColorSpace(GraphicColorGamut colorGamut)
670 {
671 std::shared_ptr<Drawing::ColorSpace> colorSpace = nullptr;
672 switch (colorGamut) {
673 case GRAPHIC_COLOR_GAMUT_DISPLAY_P3:
674 colorSpace = Drawing::ColorSpace::CreateRGB(Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::DCIP3);
675 break;
676 case GRAPHIC_COLOR_GAMUT_ADOBE_RGB:
677 colorSpace = Drawing::ColorSpace::CreateRGB(Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::ADOBE_RGB);
678 break;
679 case GRAPHIC_COLOR_GAMUT_BT2020:
680 colorSpace = Drawing::ColorSpace::CreateRGB(Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::REC2020);
681 break;
682 default:
683 break;
684 }
685
686 return colorSpace;
687 }
688
ColorSpaceConvertor(std::shared_ptr<Drawing::ShaderEffect> & inputShader,BufferDrawParam & params,Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter & parameter)689 void RSBaseRenderEngine::ColorSpaceConvertor(std::shared_ptr<Drawing::ShaderEffect> &inputShader,
690 BufferDrawParam& params, Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter& parameter)
691 {
692 RS_OPTIONAL_TRACE_BEGIN("RSBaseRenderEngine::ColorSpaceConvertor");
693
694 if (!SetColorSpaceConverterDisplayParameter(params, parameter)) {
695 RS_OPTIONAL_TRACE_END();
696 return;
697 }
698
699 if(!inputShader) {
700 RS_LOGE("RSBaseRenderEngine::ColorSpaceConvertor inputShader is null");
701 RS_OPTIONAL_TRACE_END();
702 return;
703 }
704 if (params.isHdrRedraw || RSUniRenderThread::GetCaptureParam().IsSnapshot_ ||
705 RSUniRenderThread::GetCaptureParam().isMirror_) {
706 parameter.disableHeadRoom = true;
707 }
708
709 std::shared_ptr<Drawing::ShaderEffect> outputShader;
710 auto convRet = colorSpaceConverterDisplay_->Process(inputShader, outputShader, parameter);
711 if (convRet != Media::VideoProcessingEngine::VPE_ALGO_ERR_OK) {
712 RS_LOGE("RSBaseRenderEngine::ColorSpaceConvertor colorSpaceConverterDisplay failed with %{public}u.", convRet);
713 RS_OPTIONAL_TRACE_END();
714 return;
715 }
716 if (outputShader == nullptr) {
717 RS_LOGE("RSBaseRenderEngine::ColorSpaceConvertor outputShader is nullptr.");
718 RS_OPTIONAL_TRACE_END();
719 return;
720 }
721 params.paint.SetShaderEffect(outputShader);
722 RS_OPTIONAL_TRACE_END();
723 }
724 #endif
725
DrawImage(RSPaintFilterCanvas & canvas,BufferDrawParam & params)726 void RSBaseRenderEngine::DrawImage(RSPaintFilterCanvas& canvas, BufferDrawParam& params)
727 {
728 RS_TRACE_NAME_FMT("RSBaseRenderEngine::DrawImage(GPU) targetColorGamut=%d", params.targetColorGamut);
729 auto image = std::make_shared<Drawing::Image>();
730 if (!RSBaseRenderUtil::IsBufferValid(params.buffer)) {
731 RS_LOGE("RSBaseRenderEngine::DrawImage invalid buffer!");
732 return;
733 }
734
735 std::shared_ptr<Drawing::ColorSpace> drawingColorSpace = Drawing::ColorSpace::CreateSRGB();
736 #ifdef USE_VIDEO_PROCESSING_ENGINE
737 Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter parameter;
738 GSError ret = MetadataHelper::GetColorSpaceInfo(params.buffer, parameter.inputColorSpace.colorSpaceInfo);
739 if (ret == GSERROR_OK) {
740 drawingColorSpace = GetCanvasColorSpace(canvas);
741 }
742 #endif
743
744 #ifdef RS_ENABLE_VK
745 if (RSSystemProperties::IsUseVulkan()) {
746 auto imageCache = vkImageManager_->MapVkImageFromSurfaceBuffer(params.buffer,
747 params.acquireFence, params.threadIndex);
748 auto bitmapFormat = RSBaseRenderUtil::GenerateDrawingBitmapFormat(params.buffer);
749 #ifndef ROSEN_EMULATOR
750 auto surfaceOrigin = Drawing::TextureOrigin::TOP_LEFT;
751 #else
752 auto surfaceOrigin = Drawing::TextureOrigin::BOTTOM_LEFT;
753 #endif
754 auto contextDrawingVk = canvas.GetGPUContext();
755 if (contextDrawingVk == nullptr || image == nullptr || imageCache == nullptr) {
756 RS_LOGE("contextDrawingVk or image or imageCache is nullptr.");
757 return;
758 }
759 auto& backendTexture = imageCache->GetBackendTexture();
760 if (!image->BuildFromTexture(*contextDrawingVk, backendTexture.GetTextureInfo(),
761 surfaceOrigin, bitmapFormat, drawingColorSpace,
762 NativeBufferUtils::DeleteVkImage, imageCache->RefCleanupHelper())) {
763 ROSEN_LOGE("RSBaseRenderEngine::DrawImage: backendTexture is not valid!!!");
764 return;
765 }
766 }
767 #endif // RS_ENABLE_VK
768
769 #ifdef RS_ENABLE_GL // RS_ENABLE_GL
770 if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
771 image = CreateEglImageFromBuffer(canvas, params.buffer, params.acquireFence, params.threadIndex,
772 drawingColorSpace);
773 if (image == nullptr) {
774 RS_LOGE("RSBaseRenderEngine::DrawImage: image is nullptr!");
775 return;
776 }
777 }
778 #endif // RS_ENABLE_GL
779 Drawing::SamplingOptions samplingOptions;
780 if (!RSSystemProperties::GetUniRenderEnabled()) {
781 samplingOptions = Drawing::SamplingOptions();
782 } else {
783 if (params.isMirror) {
784 samplingOptions = Drawing::SamplingOptions(Drawing::FilterMode::LINEAR, Drawing::MipmapMode::NEAREST);
785 } else {
786 samplingOptions = !params.useBilinearInterpolation
787 ? Drawing::SamplingOptions()
788 : Drawing::SamplingOptions(Drawing::FilterMode::LINEAR,
789 Drawing::MipmapMode::LINEAR);
790 }
791 }
792
793 if (params.targetColorGamut == GRAPHIC_COLOR_GAMUT_SRGB) {
794 canvas.AttachBrush(params.paint);
795 canvas.DrawImageRect(*image, params.srcRect, params.dstRect, samplingOptions,
796 Drawing::SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
797 canvas.DetachBrush();
798 } else {
799 #ifdef USE_VIDEO_PROCESSING_ENGINE
800
801 // For sdr brightness ratio
802 if (ROSEN_LNE(params.brightnessRatio, DEFAULT_BRIGHTNESS_RATIO) && !params.isHdrRedraw) {
803 Drawing::Filter filter = params.paint.GetFilter();
804 Drawing::ColorMatrix luminanceMatrix;
805 luminanceMatrix.SetScale(params.brightnessRatio, params.brightnessRatio, params.brightnessRatio, 1.0f);
806 auto luminanceColorFilter =
807 std::make_shared<Drawing::ColorFilter>(Drawing::ColorFilter::FilterType::MATRIX, luminanceMatrix);
808 filter.SetColorFilter(luminanceColorFilter);
809 params.paint.SetFilter(filter);
810 }
811
812 if (ret != GSERROR_OK) {
813 RS_LOGD("RSBaseRenderEngine::DrawImage GetColorSpaceInfo failed with %{public}u.", ret);
814 DrawImageRect(canvas, image, params, samplingOptions);
815 return;
816 }
817
818 if (!ConvertDrawingColorSpaceToSpaceInfo(drawingColorSpace, parameter.outputColorSpace.colorSpaceInfo)) {
819 RS_LOGD("RSBaseRenderEngine::DrawImage ConvertDrawingColorSpaceToSpaceInfo failed");
820 DrawImageRect(canvas, image, params, samplingOptions);
821 return;
822 }
823
824 if (parameter.inputColorSpace.colorSpaceInfo.primaries == parameter.outputColorSpace.colorSpaceInfo.primaries
825 && parameter.inputColorSpace.colorSpaceInfo.transfunc == parameter.outputColorSpace.colorSpaceInfo.transfunc) {
826 RS_LOGD("RSBaseRenderEngine::DrawImage primaries and transfunc equal.");
827 DrawImageRect(canvas, image, params, samplingOptions);
828 return;
829 }
830 Drawing::Matrix matrix;
831 auto srcWidth = params.srcRect.GetWidth();
832 auto srcHeight = params.srcRect.GetHeight();
833 auto sx = params.dstRect.GetWidth() / srcWidth;
834 auto sy = params.dstRect.GetHeight() / srcHeight;
835 auto tx = params.dstRect.GetLeft() - params.srcRect.GetLeft() * sx;
836 auto ty = params.dstRect.GetTop() - params.srcRect.GetTop() * sy;
837 if (ROSEN_EQ(srcWidth, 0.0f) || ROSEN_EQ(srcHeight, 0.0f)) {
838 RS_LOGE("RSBaseRenderEngine::DrawImage image srcRect params invalid.");
839 }
840 matrix.SetScaleTranslate(sx, sy, tx, ty);
841 auto imageShader = Drawing::ShaderEffect::CreateImageShader(
842 *image, Drawing::TileMode::CLAMP, Drawing::TileMode::CLAMP, samplingOptions, matrix);
843 if (imageShader == nullptr) {
844 RS_LOGW("RSBaseRenderEngine::DrawImage imageShader is nullptr.");
845 } else {
846 params.paint.SetShaderEffect(imageShader);
847 ColorSpaceConvertor(imageShader, params, parameter);
848 }
849 canvas.AttachBrush(params.paint);
850 canvas.DrawRect(params.dstRect);
851 canvas.DetachBrush();
852 #else
853 DrawImageRect(canvas, image, params, samplingOptions);
854 #endif // USE_VIDEO_PROCESSING_ENGINE
855 }
856 }
857
DrawImageRect(RSPaintFilterCanvas & canvas,std::shared_ptr<Drawing::Image> image,BufferDrawParam & params,Drawing::SamplingOptions & samplingOptions)858 void RSBaseRenderEngine::DrawImageRect(RSPaintFilterCanvas& canvas, std::shared_ptr<Drawing::Image> image,
859 BufferDrawParam& params, Drawing::SamplingOptions& samplingOptions)
860 {
861 canvas.AttachBrush(params.paint);
862 canvas.DrawImageRect(*image, params.srcRect, params.dstRect, samplingOptions,
863 Drawing::SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
864 canvas.DetachBrush();
865 }
866
CheckIsHdrSurfaceBuffer(const sptr<SurfaceBuffer> surfaceBuffer)867 bool RSBaseRenderEngine::CheckIsHdrSurfaceBuffer(const sptr<SurfaceBuffer> surfaceBuffer)
868 {
869 if (surfaceBuffer == nullptr) {
870 return false;
871 }
872 if (surfaceBuffer->GetFormat() != GRAPHIC_PIXEL_FMT_YCBCR_P010 &&
873 surfaceBuffer->GetFormat() != GRAPHIC_PIXEL_FMT_YCRCB_P010) {
874 return false;
875 }
876 using namespace HDI::Display::Graphic::Common::V1_0;
877 CM_ColorSpaceInfo colorSpaceInfo;
878 if (MetadataHelper::GetColorSpaceInfo(surfaceBuffer, colorSpaceInfo) == GSERROR_OK) {
879 if (colorSpaceInfo.transfunc == TRANSFUNC_PQ || colorSpaceInfo.transfunc == TRANSFUNC_HLG) {
880 return true;
881 }
882 }
883 return false;
884 }
885
RegisterDeleteBufferListener(const sptr<IConsumerSurface> & consumer,bool isForUniRedraw)886 void RSBaseRenderEngine::RegisterDeleteBufferListener(const sptr<IConsumerSurface>& consumer, bool isForUniRedraw)
887 {
888 #ifdef RS_ENABLE_VK
889 if (RSSystemProperties::IsUseVulkan()) {
890 auto regUnMapVkImageFunc = [this, isForUniRedraw](int32_t bufferId) {
891 if (vkImageManager_) {
892 vkImageManager_->UnMapVkImageFromSurfaceBuffer(bufferId);
893 }
894 };
895 if (consumer == nullptr ||
896 (consumer->RegisterDeleteBufferListener(regUnMapVkImageFunc, isForUniRedraw) != GSERROR_OK)) {
897 RS_LOGE("RSBaseRenderEngine::RegisterDeleteBufferListener: failed to register UnMapVkImage callback.");
898 }
899 return;
900 }
901 #endif // #ifdef RS_ENABLE_VK
902
903 #ifdef RS_ENABLE_EGLIMAGE
904 auto regUnMapEglImageFunc = [this, isForUniRedraw](int32_t bufferId) {
905 if (isForUniRedraw) {
906 eglImageManager_->UnMapEglImageFromSurfaceBufferForUniRedraw(bufferId);
907 } else {
908 eglImageManager_->UnMapEglImageFromSurfaceBuffer(bufferId);
909 }
910 };
911 if (consumer == nullptr ||
912 (consumer->RegisterDeleteBufferListener(regUnMapEglImageFunc, isForUniRedraw) != GSERROR_OK)) {
913 RS_LOGE("RSBaseRenderEngine::RegisterDeleteBufferListener: failed to register UnMapEglImage callback.");
914 }
915 #endif // #ifdef RS_ENABLE_EGLIMAGE
916 }
917
RegisterDeleteBufferListener(RSSurfaceHandler & handler)918 void RSBaseRenderEngine::RegisterDeleteBufferListener(RSSurfaceHandler& handler)
919 {
920 #ifdef RS_ENABLE_VK
921 if (RSSystemProperties::IsUseVulkan()) {
922 auto regUnMapVkImageFunc = [this](int32_t bufferId) {
923 if (vkImageManager_) {
924 vkImageManager_->UnMapVkImageFromSurfaceBuffer(bufferId);
925 }
926 };
927 handler.RegisterDeleteBufferListener(regUnMapVkImageFunc);
928 return;
929 }
930 #endif // #ifdef RS_ENABLE_VK
931
932 #ifdef RS_ENABLE_EGLIMAGE
933 auto regUnMapEglImageFunc = [this](int32_t bufferId) {
934 eglImageManager_->UnMapEglImageFromSurfaceBuffer(bufferId);
935 };
936 handler.RegisterDeleteBufferListener(regUnMapEglImageFunc);
937 #endif // #ifdef RS_ENABLE_EGLIMAGE
938 }
939
ShrinkCachesIfNeeded(bool isForUniRedraw)940 void RSBaseRenderEngine::ShrinkCachesIfNeeded(bool isForUniRedraw)
941 {
942 #ifdef RS_ENABLE_VK
943 if (RSSystemProperties::IsUseVulkan()) {
944 if (vkImageManager_ != nullptr) {
945 vkImageManager_->ShrinkCachesIfNeeded();
946 }
947 return;
948 }
949 #endif // RS_ENABLE_VK
950
951 #ifdef RS_ENABLE_EGLIMAGE
952 if (eglImageManager_ != nullptr) {
953 eglImageManager_->ShrinkCachesIfNeeded(isForUniRedraw);
954 }
955 #endif // RS_ENABLE_EGLIMAGE
956 }
957
ClearCacheSet(const std::set<int32_t> unmappedCache)958 void RSBaseRenderEngine::ClearCacheSet(const std::set<int32_t> unmappedCache)
959 {
960 #ifdef RS_ENABLE_VK
961 if (RSSystemProperties::GetGpuApiType() == GpuApiType::VULKAN ||
962 RSSystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
963 if (vkImageManager_ != nullptr) {
964 for (auto id : unmappedCache) {
965 vkImageManager_->UnMapVkImageFromSurfaceBuffer(id);
966 }
967 }
968 }
969 #endif // RS_ENABLE_VK
970
971 #ifdef RS_ENABLE_EGLIMAGE
972 if (eglImageManager_ != nullptr) {
973 for (auto id : unmappedCache) {
974 eglImageManager_->UnMapEglImageFromSurfaceBuffer(id);
975 }
976 }
977 #endif // RS_ENABLE_EGLIMAGE
978 }
979 } // namespace Rosen
980 } // namespace OHOS
981