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 
ColorSpaceConvertor(std::shared_ptr<Drawing::ShaderEffect> & inputShader,BufferDrawParam & params,Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter & parameter)669 void RSBaseRenderEngine::ColorSpaceConvertor(std::shared_ptr<Drawing::ShaderEffect> &inputShader,
670     BufferDrawParam& params, Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter& parameter)
671 {
672     RS_OPTIONAL_TRACE_BEGIN("RSBaseRenderEngine::ColorSpaceConvertor");
673 
674     if (!SetColorSpaceConverterDisplayParameter(params, parameter)) {
675         RS_OPTIONAL_TRACE_END();
676         return;
677     }
678 
679     if(!inputShader) {
680         RS_LOGE("RSBaseRenderEngine::ColorSpaceConvertor inputShader is null");
681         RS_OPTIONAL_TRACE_END();
682         return;
683     }
684     if (params.isHdrRedraw || RSUniRenderThread::GetCaptureParam().IsSnapshot_ ||
685         RSUniRenderThread::GetCaptureParam().isMirror_) {
686         parameter.disableHeadRoom = true;
687     }
688 
689     std::shared_ptr<Drawing::ShaderEffect> outputShader;
690     auto convRet = colorSpaceConverterDisplay_->Process(inputShader, outputShader, parameter);
691     if (convRet != Media::VideoProcessingEngine::VPE_ALGO_ERR_OK) {
692         RS_LOGE("RSBaseRenderEngine::ColorSpaceConvertor colorSpaceConverterDisplay failed with %{public}u.", convRet);
693         RS_OPTIONAL_TRACE_END();
694         return;
695     }
696     if (outputShader == nullptr) {
697         RS_LOGE("RSBaseRenderEngine::ColorSpaceConvertor outputShader is nullptr.");
698         RS_OPTIONAL_TRACE_END();
699         return;
700     }
701     params.paint.SetShaderEffect(outputShader);
702     RS_OPTIONAL_TRACE_END();
703 }
704 #endif
705 
ConvertColorGamutToDrawingColorSpace(GraphicColorGamut colorGamut)706 std::shared_ptr<Drawing::ColorSpace> RSBaseRenderEngine::ConvertColorGamutToDrawingColorSpace(
707     GraphicColorGamut colorGamut)
708 {
709     std::shared_ptr<Drawing::ColorSpace>  colorSpace = nullptr;
710     switch (colorGamut) {
711         case GRAPHIC_COLOR_GAMUT_DISPLAY_P3:
712             colorSpace = Drawing::ColorSpace::CreateRGB(
713                 Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::DCIP3);
714             break;
715         case GRAPHIC_COLOR_GAMUT_ADOBE_RGB:
716             colorSpace = Drawing::ColorSpace::CreateRGB(
717                 Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::ADOBE_RGB);
718             break;
719         case GRAPHIC_COLOR_GAMUT_BT2020:
720             colorSpace = Drawing::ColorSpace::CreateRGB(
721                 Drawing::CMSTransferFuncType::SRGB, Drawing::CMSMatrixType::REC2020);
722             break;
723         default:
724             break;
725     }
726 
727     return colorSpace;
728 }
729 
DrawImage(RSPaintFilterCanvas & canvas,BufferDrawParam & params)730 void RSBaseRenderEngine::DrawImage(RSPaintFilterCanvas& canvas, BufferDrawParam& params)
731 {
732     RS_TRACE_NAME_FMT("RSBaseRenderEngine::DrawImage(GPU) targetColorGamut=%d", params.targetColorGamut);
733     auto image = std::make_shared<Drawing::Image>();
734     if (!RSBaseRenderUtil::IsBufferValid(params.buffer)) {
735         RS_LOGE("RSBaseRenderEngine::DrawImage invalid buffer!");
736         return;
737     }
738 
739     std::shared_ptr<Drawing::ColorSpace> drawingColorSpace = Drawing::ColorSpace::CreateSRGB();
740 #ifdef USE_VIDEO_PROCESSING_ENGINE
741     Media::VideoProcessingEngine::ColorSpaceConverterDisplayParameter parameter;
742     GSError ret = MetadataHelper::GetColorSpaceInfo(params.buffer, parameter.inputColorSpace.colorSpaceInfo);
743     if (ret == GSERROR_OK) {
744         drawingColorSpace = GetCanvasColorSpace(canvas);
745     }
746 #endif
747 
748 #ifdef RS_ENABLE_VK
749     if (RSSystemProperties::IsUseVulkan()) {
750         auto imageCache = vkImageManager_->MapVkImageFromSurfaceBuffer(params.buffer,
751             params.acquireFence, params.threadIndex);
752         auto bitmapFormat = RSBaseRenderUtil::GenerateDrawingBitmapFormat(params.buffer);
753 #ifndef ROSEN_EMULATOR
754         auto surfaceOrigin = Drawing::TextureOrigin::TOP_LEFT;
755 #else
756         auto surfaceOrigin = Drawing::TextureOrigin::BOTTOM_LEFT;
757 #endif
758         auto contextDrawingVk = canvas.GetGPUContext();
759         if (contextDrawingVk == nullptr || image == nullptr || imageCache == nullptr) {
760             RS_LOGE("contextDrawingVk or image or imageCache is nullptr.");
761             return;
762         }
763         auto& backendTexture = imageCache->GetBackendTexture();
764         if (!image->BuildFromTexture(*contextDrawingVk, backendTexture.GetTextureInfo(),
765             surfaceOrigin, bitmapFormat, drawingColorSpace,
766             NativeBufferUtils::DeleteVkImage, imageCache->RefCleanupHelper())) {
767             ROSEN_LOGE("RSBaseRenderEngine::DrawImage: backendTexture is not valid!!!");
768             return;
769         }
770     }
771 #endif // RS_ENABLE_VK
772 
773 #ifdef RS_ENABLE_GL // RS_ENABLE_GL
774     if (RSSystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
775         image = CreateEglImageFromBuffer(canvas, params.buffer, params.acquireFence, params.threadIndex,
776             drawingColorSpace);
777         if (image == nullptr) {
778             RS_LOGE("RSBaseRenderEngine::DrawImage: image is nullptr!");
779             return;
780         }
781     }
782 #endif // RS_ENABLE_GL
783     Drawing::SamplingOptions samplingOptions;
784     if (!RSSystemProperties::GetUniRenderEnabled()) {
785         samplingOptions = Drawing::SamplingOptions();
786     } else {
787         if (params.isMirror) {
788             samplingOptions = Drawing::SamplingOptions(Drawing::FilterMode::LINEAR, Drawing::MipmapMode::NEAREST);
789         } else {
790             samplingOptions = !params.useBilinearInterpolation
791                                 ? Drawing::SamplingOptions()
792                                 : Drawing::SamplingOptions(Drawing::FilterMode::LINEAR,
793                                     Drawing::MipmapMode::LINEAR);
794         }
795     }
796 
797     if (params.targetColorGamut == GRAPHIC_COLOR_GAMUT_SRGB) {
798         canvas.AttachBrush(params.paint);
799         canvas.DrawImageRect(*image, params.srcRect, params.dstRect, samplingOptions,
800             Drawing::SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
801         canvas.DetachBrush();
802     } else {
803 #ifdef USE_VIDEO_PROCESSING_ENGINE
804 
805     // For sdr brightness ratio
806     if (ROSEN_LNE(params.brightnessRatio, DEFAULT_BRIGHTNESS_RATIO) && !params.isHdrRedraw) {
807         Drawing::Filter filter = params.paint.GetFilter();
808         Drawing::ColorMatrix luminanceMatrix;
809         luminanceMatrix.SetScale(params.brightnessRatio, params.brightnessRatio, params.brightnessRatio, 1.0f);
810         auto luminanceColorFilter =
811             std::make_shared<Drawing::ColorFilter>(Drawing::ColorFilter::FilterType::MATRIX, luminanceMatrix);
812         filter.SetColorFilter(luminanceColorFilter);
813         params.paint.SetFilter(filter);
814     }
815 
816     if (ret != GSERROR_OK) {
817         RS_LOGD("RSBaseRenderEngine::DrawImage GetColorSpaceInfo failed with %{public}u.", ret);
818         DrawImageRect(canvas, image, params, samplingOptions);
819         return;
820     }
821 
822     if (!ConvertDrawingColorSpaceToSpaceInfo(drawingColorSpace, parameter.outputColorSpace.colorSpaceInfo)) {
823         RS_LOGD("RSBaseRenderEngine::DrawImage ConvertDrawingColorSpaceToSpaceInfo failed");
824         DrawImageRect(canvas, image, params, samplingOptions);
825         return;
826     }
827 
828     if (parameter.inputColorSpace.colorSpaceInfo.primaries == parameter.outputColorSpace.colorSpaceInfo.primaries
829         && parameter.inputColorSpace.colorSpaceInfo.transfunc == parameter.outputColorSpace.colorSpaceInfo.transfunc) {
830         RS_LOGD("RSBaseRenderEngine::DrawImage primaries and transfunc equal.");
831         DrawImageRect(canvas, image, params, samplingOptions);
832         return;
833     }
834     Drawing::Matrix matrix;
835     auto srcWidth = params.srcRect.GetWidth();
836     auto srcHeight = params.srcRect.GetHeight();
837     auto sx = params.dstRect.GetWidth() / srcWidth;
838     auto sy = params.dstRect.GetHeight() / srcHeight;
839     auto tx = params.dstRect.GetLeft() - params.srcRect.GetLeft() * sx;
840     auto ty = params.dstRect.GetTop() - params.srcRect.GetTop() * sy;
841     if (ROSEN_EQ(srcWidth, 0.0f) || ROSEN_EQ(srcHeight, 0.0f)) {
842         RS_LOGE("RSBaseRenderEngine::DrawImage image srcRect params invalid.");
843     }
844     matrix.SetScaleTranslate(sx, sy, tx, ty);
845     auto imageShader = Drawing::ShaderEffect::CreateImageShader(
846         *image, Drawing::TileMode::CLAMP, Drawing::TileMode::CLAMP, samplingOptions, matrix);
847     if (imageShader == nullptr) {
848         RS_LOGW("RSBaseRenderEngine::DrawImage imageShader is nullptr.");
849     } else {
850         params.paint.SetShaderEffect(imageShader);
851         ColorSpaceConvertor(imageShader, params, parameter);
852     }
853     canvas.AttachBrush(params.paint);
854     canvas.DrawRect(params.dstRect);
855     canvas.DetachBrush();
856 #else
857     DrawImageRect(canvas, image, params, samplingOptions);
858 #endif // USE_VIDEO_PROCESSING_ENGINE
859     }
860 }
861 
DrawImageRect(RSPaintFilterCanvas & canvas,std::shared_ptr<Drawing::Image> image,BufferDrawParam & params,Drawing::SamplingOptions & samplingOptions)862 void RSBaseRenderEngine::DrawImageRect(RSPaintFilterCanvas& canvas, std::shared_ptr<Drawing::Image> image,
863     BufferDrawParam& params, Drawing::SamplingOptions& samplingOptions)
864 {
865     canvas.AttachBrush(params.paint);
866     canvas.DrawImageRect(*image, params.srcRect, params.dstRect, samplingOptions,
867         Drawing::SrcRectConstraint::FAST_SRC_RECT_CONSTRAINT);
868     canvas.DetachBrush();
869 }
870 
CheckIsHdrSurfaceBuffer(const sptr<SurfaceBuffer> surfaceBuffer)871 bool RSBaseRenderEngine::CheckIsHdrSurfaceBuffer(const sptr<SurfaceBuffer> surfaceBuffer)
872 {
873     if (surfaceBuffer == nullptr) {
874         return false;
875     }
876     if (surfaceBuffer->GetFormat() != GRAPHIC_PIXEL_FMT_YCBCR_P010 &&
877         surfaceBuffer->GetFormat() != GRAPHIC_PIXEL_FMT_YCRCB_P010) {
878         return false;
879     }
880     using namespace HDI::Display::Graphic::Common::V1_0;
881     CM_ColorSpaceInfo colorSpaceInfo;
882     if (MetadataHelper::GetColorSpaceInfo(surfaceBuffer, colorSpaceInfo) == GSERROR_OK) {
883         if (colorSpaceInfo.transfunc == TRANSFUNC_PQ || colorSpaceInfo.transfunc == TRANSFUNC_HLG) {
884             return true;
885         }
886     }
887     return false;
888 }
889 
RegisterDeleteBufferListener(const sptr<IConsumerSurface> & consumer,bool isForUniRedraw)890 void RSBaseRenderEngine::RegisterDeleteBufferListener(const sptr<IConsumerSurface>& consumer, bool isForUniRedraw)
891 {
892 #ifdef RS_ENABLE_VK
893     if (RSSystemProperties::IsUseVulkan()) {
894         auto regUnMapVkImageFunc = [this, isForUniRedraw](int32_t bufferId) {
895             if (vkImageManager_) {
896                 vkImageManager_->UnMapVkImageFromSurfaceBuffer(bufferId);
897             }
898         };
899         if (consumer == nullptr ||
900             (consumer->RegisterDeleteBufferListener(regUnMapVkImageFunc, isForUniRedraw) != GSERROR_OK)) {
901             RS_LOGE("RSBaseRenderEngine::RegisterDeleteBufferListener: failed to register UnMapVkImage callback.");
902         }
903         return;
904     }
905 #endif // #ifdef RS_ENABLE_VK
906 
907 #ifdef RS_ENABLE_EGLIMAGE
908     auto regUnMapEglImageFunc = [this, isForUniRedraw](int32_t bufferId) {
909         if (isForUniRedraw) {
910             eglImageManager_->UnMapEglImageFromSurfaceBufferForUniRedraw(bufferId);
911         } else {
912             eglImageManager_->UnMapEglImageFromSurfaceBuffer(bufferId);
913         }
914     };
915     if (consumer == nullptr ||
916         (consumer->RegisterDeleteBufferListener(regUnMapEglImageFunc, isForUniRedraw) != GSERROR_OK)) {
917         RS_LOGE("RSBaseRenderEngine::RegisterDeleteBufferListener: failed to register UnMapEglImage callback.");
918     }
919 #endif // #ifdef RS_ENABLE_EGLIMAGE
920 }
921 
RegisterDeleteBufferListener(RSSurfaceHandler & handler)922 void RSBaseRenderEngine::RegisterDeleteBufferListener(RSSurfaceHandler& handler)
923 {
924 #ifdef RS_ENABLE_VK
925     if (RSSystemProperties::IsUseVulkan()) {
926         auto regUnMapVkImageFunc = [this](int32_t bufferId) {
927             if (vkImageManager_) {
928                 vkImageManager_->UnMapVkImageFromSurfaceBuffer(bufferId);
929             }
930         };
931         handler.RegisterDeleteBufferListener(regUnMapVkImageFunc);
932         return;
933     }
934 #endif // #ifdef RS_ENABLE_VK
935 
936 #ifdef RS_ENABLE_EGLIMAGE
937     auto regUnMapEglImageFunc = [this](int32_t bufferId) {
938         eglImageManager_->UnMapEglImageFromSurfaceBuffer(bufferId);
939     };
940     handler.RegisterDeleteBufferListener(regUnMapEglImageFunc);
941 #endif // #ifdef RS_ENABLE_EGLIMAGE
942 }
943 
ShrinkCachesIfNeeded(bool isForUniRedraw)944 void RSBaseRenderEngine::ShrinkCachesIfNeeded(bool isForUniRedraw)
945 {
946 #ifdef RS_ENABLE_VK
947     if (RSSystemProperties::IsUseVulkan()) {
948         if (vkImageManager_ != nullptr) {
949             vkImageManager_->ShrinkCachesIfNeeded();
950         }
951         return;
952     }
953 #endif // RS_ENABLE_VK
954 
955 #ifdef RS_ENABLE_EGLIMAGE
956     if (eglImageManager_ != nullptr) {
957         eglImageManager_->ShrinkCachesIfNeeded(isForUniRedraw);
958     }
959 #endif // RS_ENABLE_EGLIMAGE
960 }
961 
ClearCacheSet(const std::set<int32_t> unmappedCache)962 void RSBaseRenderEngine::ClearCacheSet(const std::set<int32_t> unmappedCache)
963 {
964 #ifdef RS_ENABLE_VK
965     if (RSSystemProperties::GetGpuApiType() == GpuApiType::VULKAN ||
966         RSSystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
967         if (vkImageManager_ != nullptr) {
968             for (auto id : unmappedCache) {
969                 vkImageManager_->UnMapVkImageFromSurfaceBuffer(id);
970             }
971         }
972     }
973 #endif // RS_ENABLE_VK
974 
975 #ifdef RS_ENABLE_EGLIMAGE
976     if (eglImageManager_ != nullptr) {
977         for (auto id : unmappedCache) {
978             eglImageManager_->UnMapEglImageFromSurfaceBuffer(id);
979         }
980     }
981 #endif // RS_ENABLE_EGLIMAGE
982 }
983 } // namespace Rosen
984 } // namespace OHOS
985