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