1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.. All rights reserved.
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 "skia_surface.h"
17 
18 #include "include/gpu/GrBackendSemaphore.h"
19 
20 #include "draw/surface.h"
21 #include "include/gpu/GrBackendSemaphore.h"
22 #include "utils/log.h"
23 
24 #include "skia_bitmap.h"
25 #include "skia_canvas.h"
26 #include "skia_image_info.h"
27 #ifdef RS_ENABLE_GPU
28 #include "skia_gpu_context.h"
29 #endif
30 #include "skia_image.h"
31 #include "skia_image_info.h"
32 #include "skia_texture_info.h"
33 #include "utils/system_properties.h"
34 
35 namespace OHOS {
36 namespace Rosen {
37 namespace Drawing {
38 #ifdef RS_ENABLE_GPU
39 static constexpr int TEXTURE_SAMPLE_COUNT = 0;
40 static constexpr int FB_SAMPLE_COUNT = 0;
41 static constexpr int STENCIL_BITS = 8;
42 static constexpr uint32_t SURFACE_PROPS_FLAGS = 0;
43 #endif
44 
45 namespace {
ConvertToSkiaBackendAccess(BackendAccess access)46 SkSurface::BackendHandleAccess ConvertToSkiaBackendAccess(BackendAccess access)
47 {
48     switch (access) {
49         case BackendAccess::FLUSH_READ:
50             return SkSurface::BackendHandleAccess::kFlushRead_BackendHandleAccess;
51         case BackendAccess::FLUSH_WRITE:
52             return SkSurface::BackendHandleAccess::kFlushWrite_BackendHandleAccess;
53         case BackendAccess::DISCARD_WRITE:
54             return SkSurface::BackendHandleAccess::kDiscardWrite_BackendHandleAccess;
55         default:
56             return SkSurface::BackendHandleAccess::kFlushRead_BackendHandleAccess;
57     }
58     return SkSurface::BackendHandleAccess::kFlushRead_BackendHandleAccess;
59 }
60 }
61 
SkiaSurface()62 SkiaSurface::SkiaSurface() {}
63 
PostSkSurfaceToTargetThread()64 void SkiaSurface::PostSkSurfaceToTargetThread()
65 {
66     auto canvas = GetCanvas();
67     if (canvas == nullptr) {
68         return;
69     }
70     auto ctx = canvas->GetGPUContext();
71     if (ctx == nullptr) {
72         return;
73     }
74     auto skctx = ctx->GetImpl<SkiaGPUContext>();
75     if (skctx == nullptr) {
76         return;
77     }
78     auto grctx = skctx->GetGrContext();
79     if (grctx == nullptr) {
80         return;
81     }
82     auto func = SkiaGPUContext::GetPostFunc(grctx);
83     if (func) {
84         func([skSurface = std::move(skSurface_), skImage = std::move(skImage_)]() {});
85     }
86 }
87 
~SkiaSurface()88 SkiaSurface::~SkiaSurface()
89 {
90     PostSkSurfaceToTargetThread();
91 }
92 
Bind(const Bitmap & bitmap)93 bool SkiaSurface::Bind(const Bitmap& bitmap)
94 {
95     const auto &skBitmap = bitmap.GetImpl<SkiaBitmap>()->ExportSkiaBitmap();
96     skSurface_ = SkSurface::MakeRasterDirect(skBitmap.info(), skBitmap.getPixels(), skBitmap.rowBytes());
97     if (skSurface_ == nullptr) {
98         LOGD("SkiaSurface bind Bitmap failed: skSurface is nullptr");
99         return false;
100     }
101     return true;
102 }
103 
104 #ifdef RS_ENABLE_GPU
Bind(const Image & image)105 bool SkiaSurface::Bind(const Image& image)
106 {
107     auto skiaImageImpl = image.GetImpl<SkiaImage>();
108     if (skiaImageImpl == nullptr) {
109         LOGD("SkiaSurface bind Image failed: skiaImageImpl is nullptr");
110         return false;
111     }
112     auto skImage = skiaImageImpl->GetImage();
113     auto grContext = skiaImageImpl->GetGrContext();
114     if (skImage == nullptr || grContext == nullptr) {
115         LOGD("SkiaSurface bind Image failed: image is not GPU image");
116         return false;
117     }
118 
119     if (skImage->isLazyGenerated()) {
120         skImage = skImage->makeTextureImage(grContext.get());
121     }
122 
123     GrSurfaceOrigin grSurfaceOrigin;
124     GrBackendTexture grBackendTexture;
125     SkSurfaceProps surfaceProps(SURFACE_PROPS_FLAGS, kRGB_H_SkPixelGeometry);
126     grBackendTexture = skImage->getBackendTexture(false, &grSurfaceOrigin);
127     if (!grBackendTexture.isValid()) {
128         LOGD("SkiaSurface bind Image failed: BackendTexture is invalid");
129         return false;
130     }
131 
132     skSurface_ = SkSurface::MakeFromBackendTexture(grContext.get(), grBackendTexture, grSurfaceOrigin,
133         TEXTURE_SAMPLE_COUNT, skImage->colorType(), skImage->refColorSpace(), &surfaceProps);
134     if (skSurface_ == nullptr) {
135         LOGD("SkiaSurface bind Image failed: skSurface is nullptr");
136         return false;
137     }
138 
139     skImage_ = skImage;
140     return true;
141 }
142 
Bind(const FrameBuffer & frameBuffer)143 bool SkiaSurface::Bind(const FrameBuffer& frameBuffer)
144 {
145     if (frameBuffer.gpuContext == nullptr) {
146         LOGD("SkiaSurface bind FBO failed: gpuContext is invalid");
147         return false;
148     }
149     auto skiaContext = frameBuffer.gpuContext->GetImpl<SkiaGPUContext>();
150 
151     GrGLFramebufferInfo framebufferInfo;
152     framebufferInfo.fFBOID = frameBuffer.FBOID;
153     framebufferInfo.fFormat = frameBuffer.Format;
154     GrBackendRenderTarget backendRenderTarget(
155         frameBuffer.width, frameBuffer.height, FB_SAMPLE_COUNT, STENCIL_BITS, framebufferInfo);
156 
157     SkColorType colorType = SkiaImageInfo::ConvertToSkColorType(frameBuffer.colorType);
158     sk_sp<SkColorSpace> skColorSpace = nullptr;
159     if (frameBuffer.colorSpace != nullptr) {
160         auto colorSpaceImpl = frameBuffer.colorSpace->GetImpl<SkiaColorSpace>();
161         if (colorSpaceImpl != nullptr) {
162             skColorSpace = colorSpaceImpl->GetColorSpace();
163         }
164     }
165 
166     SkSurfaceProps surfaceProps(SURFACE_PROPS_FLAGS, kRGB_H_SkPixelGeometry);
167 
168     skSurface_ = SkSurface::MakeFromBackendRenderTarget(skiaContext->GetGrContext().get(),
169         backendRenderTarget, kBottomLeft_GrSurfaceOrigin, colorType, skColorSpace, &surfaceProps);
170     if (skSurface_ == nullptr) {
171         LOGD("SkiaSurface bind FBO failed: skSurface is nullptr");
172         return false;
173     }
174     return true;
175 }
176 
177 #ifdef RS_ENABLE_VK
MakeFromBackendRenderTarget(GPUContext * gpuContext,const TextureInfo & info,TextureOrigin origin,ColorType colorType,std::shared_ptr<ColorSpace> colorSpace,void (* deleteVkImage)(void *),void * cleanHelper)178 std::shared_ptr<Surface> SkiaSurface::MakeFromBackendRenderTarget(GPUContext* gpuContext, const TextureInfo& info,
179     TextureOrigin origin, ColorType colorType, std::shared_ptr<ColorSpace> colorSpace,
180     void (*deleteVkImage)(void *), void* cleanHelper)
181 {
182     if (!SystemProperties::IsUseVulkan()) {
183         return nullptr;
184     }
185     sk_sp<GrDirectContext> grContext = nullptr;
186     if (gpuContext) {
187         auto skiaGpuContext = gpuContext->GetImpl<SkiaGPUContext>();
188         if (skiaGpuContext) {
189             grContext = skiaGpuContext->GetGrContext();
190         }
191     }
192     GrVkImageInfo image_info;
193     SkiaTextureInfo::ConvertToGrBackendTexture(info).getVkImageInfo(&image_info);
194     GrBackendRenderTarget backendRenderTarget(info.GetWidth(), info.GetHeight(), 0, image_info);
195     SkSurfaceProps surfaceProps(0, SkPixelGeometry::kUnknown_SkPixelGeometry);
196 
197     sk_sp<SkColorSpace> skColorSpace = nullptr;
198     if (colorSpace != nullptr) {
199         auto colorSpaceImpl = colorSpace->GetImpl<SkiaColorSpace>();
200         skColorSpace = colorSpaceImpl ? colorSpaceImpl->GetColorSpace() : SkColorSpace::MakeSRGB();
201     } else {
202         skColorSpace = SkColorSpace::MakeSRGB();
203     }
204 
205     sk_sp<SkSurface> skSurface =
206         SkSurface::MakeFromBackendRenderTarget(grContext.get(),
207         backendRenderTarget, SkiaTextureInfo::ConvertToGrSurfaceOrigin(origin),
208         SkiaImageInfo::ConvertToSkColorType(colorType),
209         skColorSpace, &surfaceProps, deleteVkImage, cleanHelper);
210     if (skSurface == nullptr) {
211         return nullptr;
212     }
213 
214     std::shared_ptr<Surface> surface = std::make_shared<Surface>();
215     surface->GetImpl<SkiaSurface>()->SetSkSurface(skSurface);
216     return surface;
217 }
218 #endif
MakeFromBackendTexture(GPUContext * gpuContext,const TextureInfo & info,TextureOrigin origin,int sampleCnt,ColorType colorType,std::shared_ptr<ColorSpace> colorSpace,void (* deleteVkImage)(void *),void * cleanHelper)219 std::shared_ptr<Surface> SkiaSurface::MakeFromBackendTexture(GPUContext* gpuContext, const TextureInfo& info,
220     TextureOrigin origin, int sampleCnt, ColorType colorType,
221     std::shared_ptr<ColorSpace> colorSpace, void (*deleteVkImage)(void *), void* cleanHelper)
222 {
223     sk_sp<GrDirectContext> grContext = nullptr;
224     if (gpuContext) {
225         auto skiaGpuContext = gpuContext->GetImpl<SkiaGPUContext>();
226         if (skiaGpuContext) {
227             grContext = skiaGpuContext->GetGrContext();
228         }
229     }
230     sk_sp<SkColorSpace> skColorSpace = nullptr;
231     if (colorSpace != nullptr) {
232         auto colorSpaceImpl = colorSpace->GetImpl<SkiaColorSpace>();
233         skColorSpace = colorSpaceImpl ? colorSpaceImpl->GetColorSpace() : SkColorSpace::MakeSRGB();
234     } else {
235         skColorSpace = SkColorSpace::MakeSRGB();
236     }
237 
238     sk_sp<SkSurface> skSurface = nullptr;
239     SkSurfaceProps surfaceProps(0, SkPixelGeometry::kUnknown_SkPixelGeometry);
240 #ifdef RS_ENABLE_VK
241     if (SystemProperties::GetGpuApiType() == GpuApiType::VULKAN) {
242         GrVkImageInfo image_info;
243         SkiaTextureInfo::ConvertToGrBackendTexture(info).getVkImageInfo(&image_info);
244         GrBackendTexture backendRenderTarget(info.GetWidth(), info.GetHeight(), image_info);
245         skSurface = SkSurface::MakeFromBackendTexture(grContext.get(),
246             backendRenderTarget, SkiaTextureInfo::ConvertToGrSurfaceOrigin(origin),
247             sampleCnt, SkiaImageInfo::ConvertToSkColorType(colorType),
248             skColorSpace, &surfaceProps, deleteVkImage, cleanHelper);
249     }
250 #endif
251 #ifdef RS_ENABLE_GL
252     if (SystemProperties::GetGpuApiType() == GpuApiType::OPENGL) {
253         GrBackendTexture glBackendTexture = SkiaTextureInfo::ConvertToGrBackendTexture(info);
254         skSurface = SkSurface::MakeFromBackendTexture(grContext.get(),
255             glBackendTexture, SkiaTextureInfo::ConvertToGrSurfaceOrigin(origin),
256             sampleCnt, SkiaImageInfo::ConvertToSkColorType(colorType),
257             skColorSpace, &surfaceProps, deleteVkImage, cleanHelper);
258     }
259 #endif
260     if (skSurface == nullptr) {
261         return nullptr;
262     }
263 
264     std::shared_ptr<Surface> surface = std::make_shared<Surface>();
265     surface->GetImpl<SkiaSurface>()->SetSkSurface(skSurface);
266     return surface;
267 }
268 
MakeRenderTarget(GPUContext * gpuContext,bool budgeted,const ImageInfo & imageInfo)269 std::shared_ptr<Surface> SkiaSurface::MakeRenderTarget(GPUContext* gpuContext,
270     bool budgeted, const ImageInfo& imageInfo)
271 {
272     sk_sp<GrDirectContext> grContext = nullptr;
273     if (gpuContext) {
274         auto skiaGpuContext = gpuContext->GetImpl<SkiaGPUContext>();
275         if (skiaGpuContext) {
276             grContext = skiaGpuContext->GetGrContext();
277         }
278     }
279     SkImageInfo skImageInfo = SkiaImageInfo::ConvertToSkImageInfo(imageInfo);
280     sk_sp<SkSurface> skSurface =
281         SkSurface::MakeRenderTarget(grContext.get(), static_cast<SkBudgeted>(budgeted), skImageInfo);
282     if (skSurface == nullptr) {
283         LOGD("skSurface nullptr, %{public}s, %{public}d [%{public}d %{public}d]", __FUNCTION__, __LINE__,
284             imageInfo.GetWidth(), imageInfo.GetHeight());
285         return nullptr;
286     }
287     std::shared_ptr<Surface> surface = std::make_shared<Surface>();
288     surface->GetImpl<SkiaSurface>()->SetSkSurface(skSurface);
289     return surface;
290 }
291 #endif
292 
MakeRaster(const ImageInfo & imageInfo)293 std::shared_ptr<Surface> SkiaSurface::MakeRaster(const ImageInfo& imageInfo)
294 {
295     SkImageInfo skImageInfo = SkiaImageInfo::ConvertToSkImageInfo(imageInfo);
296     sk_sp<SkSurface> skSurface = SkSurface::MakeRaster(skImageInfo);
297     if (skSurface == nullptr) {
298         LOGD("skSurface nullptr, %{public}s, %{public}d", __FUNCTION__, __LINE__);
299         return nullptr;
300     }
301     std::shared_ptr<Surface> surface = std::make_shared<Surface>();
302     surface->GetImpl<SkiaSurface>()->SetSkSurface(skSurface);
303     return surface;
304 }
305 
MakeRasterDirect(const ImageInfo & imageInfo,void * pixels,size_t rowBytes)306 std::shared_ptr<Surface> SkiaSurface::MakeRasterDirect(const ImageInfo& imageInfo, void* pixels, size_t rowBytes)
307 {
308     SkImageInfo skImageInfo = SkiaImageInfo::ConvertToSkImageInfo(imageInfo);
309     sk_sp<SkSurface> skSurface = SkSurface::MakeRasterDirect(skImageInfo, pixels, rowBytes);
310     if (skSurface == nullptr) {
311         LOGD("skSurface nullptr, %{public}s, %{public}d", __FUNCTION__, __LINE__);
312         return nullptr;
313     }
314     std::shared_ptr<Surface> surface = std::make_shared<Surface>();
315     surface->GetImpl<SkiaSurface>()->SetSkSurface(skSurface);
316     return surface;
317 }
318 
MakeRasterN32Premul(int32_t width,int32_t height)319 std::shared_ptr<Surface> SkiaSurface::MakeRasterN32Premul(int32_t width, int32_t height)
320 {
321     sk_sp<SkSurface> skSurface = SkSurface::MakeRasterN32Premul(width, height);
322     if (skSurface == nullptr) {
323         LOGD("skSurface nullptr, %{public}s, %{public}d", __FUNCTION__, __LINE__);
324         return nullptr;
325     }
326     std::shared_ptr<Surface> surface = std::make_shared<Surface>();
327     surface->GetImpl<SkiaSurface>()->SetSkSurface(skSurface);
328     return surface;
329 }
330 
GetCanvas() const331 std::shared_ptr<Canvas> SkiaSurface::GetCanvas() const
332 {
333     if (skSurface_ == nullptr || skSurface_->getCanvas() == nullptr) {
334         LOGD("skSurface is invalid");
335         return nullptr;
336     }
337 
338     auto canvas = std::make_shared<Canvas>();
339     canvas->GetImpl<SkiaCanvas>()->ImportSkCanvas(skSurface_->getCanvas());
340     return canvas;
341 }
342 
GetImageSnapshot() const343 std::shared_ptr<Image> SkiaSurface::GetImageSnapshot() const
344 {
345     if (skSurface_ == nullptr) {
346         LOGD("skSurface is nullptr");
347         return nullptr;
348     }
349 
350     auto skImage = skSurface_->makeImageSnapshot();
351     if (skImage == nullptr) {
352         LOGD("skSurface makeImageSnashot failed");
353         return nullptr;
354     }
355 
356     auto image = std::make_shared<Image>();
357     image->GetImpl<SkiaImage>()->SetSkImage(skImage);
358     return image;
359 }
360 
GetImageSnapshot(const RectI & bounds,bool allowRefCache) const361 std::shared_ptr<Image> SkiaSurface::GetImageSnapshot(const RectI& bounds, bool allowRefCache) const
362 {
363     if (skSurface_ == nullptr) {
364         LOGD("skSurface is nullptr");
365         return nullptr;
366     }
367 
368     auto iRect = SkIRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(), bounds.GetRight(), bounds.GetBottom());
369     auto skImage = skSurface_->makeImageSnapshot(iRect, allowRefCache);
370     if (skImage == nullptr) {
371         LOGD("skSurface makeImageSnashot failed");
372         return nullptr;
373     }
374 
375     auto image = std::make_shared<Image>();
376     image->GetImpl<SkiaImage>()->SetSkImage(skImage);
377     return image;
378 }
379 
GetBackendTexture(BackendAccess access) const380 BackendTexture SkiaSurface::GetBackendTexture(BackendAccess access) const
381 {
382     if (skSurface_ == nullptr) {
383         LOGD("skSurface is nullptr");
384         return {};
385     }
386 
387     GrBackendTexture grBackendTexture = skSurface_->getBackendTexture(ConvertToSkiaBackendAccess(access));
388     auto backendTexture = BackendTexture(true);
389 #ifdef RS_ENABLE_VK
390     if (SystemProperties::IsUseVulkan()) {
391         TextureInfo info;
392         SkiaTextureInfo::ConvertToVKTexture(grBackendTexture, info);
393         backendTexture.SetTextureInfo(info);
394     } else {
395         backendTexture.SetTextureInfo(SkiaTextureInfo::ConvertToTextureInfo(grBackendTexture));
396     }
397 #else
398     backendTexture.SetTextureInfo(SkiaTextureInfo::ConvertToTextureInfo(grBackendTexture));
399 #endif
400     return backendTexture;
401 }
402 
MakeSurface(int width,int height) const403 std::shared_ptr<Surface> SkiaSurface::MakeSurface(int width, int height) const
404 {
405     if (skSurface_ == nullptr) {
406         LOGD("skSurface is nullptr");
407         return nullptr;
408     }
409     auto surface = skSurface_->makeSurface(width, height);
410     if (surface == nullptr) {
411         LOGD("SkiaSurface::MakeSurface failed");
412         return nullptr;
413     }
414 
415     auto drawingSurface = std::make_shared<Surface>();
416     drawingSurface->GetImpl<SkiaSurface>()->SetSkSurface(surface);
417     return drawingSurface;
418 }
419 
MakeSurface(const ImageInfo & imageInfo) const420 std::shared_ptr<Surface> SkiaSurface::MakeSurface(const ImageInfo& imageInfo) const
421 {
422     if (skSurface_ == nullptr) {
423         LOGD("skSurface is nullptr");
424         return nullptr;
425     }
426     SkImageInfo skImageInfo = SkiaImageInfo::ConvertToSkImageInfo(imageInfo);
427     auto surface = skSurface_->makeSurface(skImageInfo);
428     if (surface == nullptr) {
429         LOGD("SkiaSurface::MakeSurface failed");
430         return nullptr;
431     }
432 
433     auto drawingSurface = std::make_shared<Surface>();
434     drawingSurface->GetImpl<SkiaSurface>()->SetSkSurface(surface);
435     return drawingSurface;
436 }
437 
SetSkSurface(const sk_sp<SkSurface> & skSurface)438 void SkiaSurface::SetSkSurface(const sk_sp<SkSurface>& skSurface)
439 {
440     skSurface_ = skSurface;
441 }
442 
GetSkSurface() const443 sk_sp<SkSurface> SkiaSurface::GetSkSurface() const
444 {
445     return skSurface_;
446 }
447 
FlushAndSubmit(bool syncCpu)448 void SkiaSurface::FlushAndSubmit(bool syncCpu)
449 {
450     if (skSurface_ == nullptr) {
451         LOGD("skSurface is nullptr");
452         return;
453     }
454 
455     skSurface_->flushAndSubmit(syncCpu);
456 }
457 
Flush(FlushInfo * drawingflushInfo)458 void SkiaSurface::Flush(FlushInfo *drawingflushInfo)
459 {
460     if (skSurface_ == nullptr) {
461         LOGD("skSurface is nullptr");
462         // handle exception such as skia
463         if (!drawingflushInfo) {
464             return;
465         }
466         if (drawingflushInfo->submittedProc) {
467             drawingflushInfo->submittedProc(drawingflushInfo->submittedContext, false);
468         }
469         if (drawingflushInfo->finishedProc) {
470             drawingflushInfo->finishedProc(drawingflushInfo->finishedContext);
471         }
472         return;
473     }
474     if (drawingflushInfo != nullptr) {
475         GrFlushInfo flushInfo;
476         flushInfo.fNumSemaphores = drawingflushInfo->numSemaphores;
477         flushInfo.fSignalSemaphores = static_cast<GrBackendSemaphore*>(drawingflushInfo->backendSemaphore);
478         flushInfo.fFinishedProc = drawingflushInfo->finishedProc;
479         flushInfo.fFinishedContext = static_cast<GrGpuFinishedContext>(drawingflushInfo->finishedContext);
480         flushInfo.fSubmittedProc = drawingflushInfo->submittedProc;
481         flushInfo.fSubmittedContext = static_cast<GrGpuSubmittedContext>(drawingflushInfo->submittedContext);
482         skSurface_->flush(drawingflushInfo->backendSurfaceAccess == false ?
483             SkSurface::BackendSurfaceAccess::kNoAccess : SkSurface::BackendSurfaceAccess::kPresent, flushInfo);
484         return;
485     }
486     skSurface_->flush();
487 }
488 
489 #ifdef RS_ENABLE_GL
Wait(const std::vector<GrGLsync> & syncs)490 void SkiaSurface::Wait(const std::vector<GrGLsync>& syncs)
491 {
492     if (!SystemProperties::IsUseGl()) {
493         return;
494     }
495 
496     if (skSurface_ == nullptr) {
497         LOGD("skSurface is nullptr");
498         return;
499     }
500 
501     uint32_t count = syncs.size();
502     if (count == 0) {
503         LOGD("GrGLsync count is zero");
504         return;
505     } else {
506         std::vector<GrBackendSemaphore> semaphores;
507         semaphores.reserve(count);
508         for (auto& sync : syncs) {
509             GrBackendSemaphore backendSemaphore;
510             backendSemaphore.initGL(sync);
511             semaphores.emplace_back(backendSemaphore);
512         }
513         skSurface_->wait(count, semaphores.data());
514     }
515 }
516 #endif
517 
518 #ifdef RS_ENABLE_VK
Wait(int32_t time,const VkSemaphore & semaphore)519 void SkiaSurface::Wait(int32_t time, const VkSemaphore& semaphore)
520 {
521     if (!SystemProperties::IsUseVulkan()) {
522         return;
523     }
524     if (skSurface_ == nullptr) {
525         LOGD("skSurface is nullptr");
526         return;
527     }
528     GrBackendSemaphore backendSemaphore;
529     backendSemaphore.initVulkan(semaphore);
530     skSurface_->wait(time, &backendSemaphore);
531 }
532 
SetDrawingArea(const std::vector<RectI> & rects)533 void SkiaSurface::SetDrawingArea(const std::vector<RectI>& rects)
534 {
535     if (!SystemProperties::IsUseVulkan()) {
536         return;
537     }
538     if (skSurface_ == nullptr) {
539         LOGD("skSurface is nullptr");
540         return;
541     }
542     std::vector<SkIRect> skIRects;
543     for (auto &rect : rects) {
544         SkIRect skIRect = {rect.GetLeft(), rect.GetTop(), rect.GetRight(), rect.GetBottom()};
545         skIRects.push_back(skIRect);
546     }
547     skSurface_->setDrawingArea(skIRects);
548 }
549 
ClearDrawingArea()550 void SkiaSurface::ClearDrawingArea()
551 {
552     if (SystemProperties::GetGpuApiType() != GpuApiType::VULKAN &&
553         SystemProperties::GetGpuApiType() != GpuApiType::DDGR) {
554         return;
555     }
556     if (skSurface_ == nullptr) {
557         LOGD("skSurface is nullptr");
558         return;
559     }
560     skSurface_->clearDrawingArea();
561 }
562 #endif
563 
Width() const564 int SkiaSurface::Width() const
565 {
566     if (skSurface_ == nullptr) {
567         LOGW("skSurface is nullptr");
568         return 0;
569     }
570     return skSurface_->width();
571 }
572 
Height() const573 int SkiaSurface::Height() const
574 {
575     if (skSurface_ == nullptr) {
576         LOGW("skSurface is nullptr");
577         return 0;
578     }
579     return skSurface_->height();
580 }
581 
582 } // namespace Drawing
583 } // namespace Rosen
584 } // namespace OHOS
585