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