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