1 /*
2 * Copyright (c) 2022-2023 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_vk_image_manager.h"
17
18 #include "SkImageInfo.h"
19 #include "include/core/SkColorSpace.h"
20 #include "native_buffer_inner.h"
21 #include "platform/common/rs_log.h"
22 #include "include/gpu/GrBackendSurface.h"
23 #include "pipeline/rs_main_thread.h"
24 #include "pipeline/rs_hardware_thread.h"
25 #include "pipeline/parallel_render/rs_sub_thread_manager.h"
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
WaitAcquireFence(const sptr<SyncFence> & acquireFence)30 void WaitAcquireFence(const sptr<SyncFence>& acquireFence)
31 {
32 if (acquireFence == nullptr) {
33 return;
34 }
35 acquireFence->Wait(3000); // 3000ms
36 }
37 }
38
~NativeVkImageRes()39 NativeVkImageRes::~NativeVkImageRes()
40 {
41 NativeBufferUtils::DeleteVkImage(mVulkanCleanupHelper);
42 DestroyNativeWindowBuffer(mNativeWindowBuffer);
43 }
44
Create(sptr<OHOS::SurfaceBuffer> buffer)45 std::shared_ptr<NativeVkImageRes> NativeVkImageRes::Create(sptr<OHOS::SurfaceBuffer> buffer)
46 {
47 auto width = buffer->GetSurfaceBufferWidth();
48 auto height = buffer->GetSurfaceBufferHeight();
49 NativeWindowBuffer* nativeWindowBuffer = CreateNativeWindowBufferFromSurfaceBuffer(&buffer);
50 auto backendTexture = NativeBufferUtils::MakeBackendTextureFromNativeBuffer(nativeWindowBuffer,
51 width, height);
52 #ifndef USE_ROSEN_DRAWING
53 if (!backendTexture.isValid()) {
54 DestroyNativeWindowBuffer(nativeWindowBuffer);
55 return nullptr;
56 }
57 GrVkImageInfo imageInfo;
58 backendTexture.getVkImageInfo(&imageInfo);
59
60 return std::make_unique<NativeVkImageRes>(
61 nativeWindowBuffer,
62 backendTexture,
63 new NativeBufferUtils::VulkanCleanupHelper(RsVulkanContext::GetSingleton(),
64 imageInfo.fImage, imageInfo.fAlloc.fMemory));
65 #else
66 if (!backendTexture.IsValid()) {
67 DestroyNativeWindowBuffer(nativeWindowBuffer);
68 return nullptr;
69 }
70 return std::make_unique<NativeVkImageRes>(
71 nativeWindowBuffer,
72 backendTexture,
73 new NativeBufferUtils::VulkanCleanupHelper(RsVulkanContext::GetSingleton(),
74 backendTexture.GetTextureInfo().GetVKTextureInfo()->vkImage,
75 backendTexture.GetTextureInfo().GetVKTextureInfo()->vkAlloc.memory));
76 #endif
77 }
78
MapVkImageFromSurfaceBuffer(const sptr<OHOS::SurfaceBuffer> & buffer,const sptr<SyncFence> & acquireFence,uint32_t threadIndex)79 std::shared_ptr<NativeVkImageRes> RSVkImageManager::MapVkImageFromSurfaceBuffer(
80 const sptr<OHOS::SurfaceBuffer>& buffer,
81 const sptr<SyncFence>& acquireFence,
82 uint32_t threadIndex)
83 {
84 WaitAcquireFence(acquireFence);
85 std::lock_guard<std::mutex> lock(opMutex_);
86 auto bufferId = buffer->GetSeqNum();
87 if (imageCacheSeqs_.count(bufferId) == 0) {
88 return NewImageCacheFromBuffer(buffer, threadIndex);
89 } else {
90 return imageCacheSeqs_[bufferId];
91 }
92 }
93
CreateImageCacheFromBuffer(sptr<OHOS::SurfaceBuffer> buffer,const sptr<SyncFence> & acquireFence)94 std::shared_ptr<NativeVkImageRes> RSVkImageManager::CreateImageCacheFromBuffer(sptr<OHOS::SurfaceBuffer> buffer,
95 const sptr<SyncFence>& acquireFence)
96 {
97 WaitAcquireFence(acquireFence);
98 auto bufferId = buffer->GetSeqNum();
99 auto imageCache = NativeVkImageRes::Create(buffer);
100 if (imageCache == nullptr) {
101 ROSEN_LOGE(
102 "RSVkImageManager::CreateImageCacheFromBuffer: failed to create ImageCache for buffer id %{public}d.",
103 bufferId);
104 return nullptr;
105 }
106 return imageCache;
107 }
108
NewImageCacheFromBuffer(const sptr<OHOS::SurfaceBuffer> & buffer,uint32_t threadIndex)109 std::shared_ptr<NativeVkImageRes> RSVkImageManager::NewImageCacheFromBuffer(
110 const sptr<OHOS::SurfaceBuffer>& buffer, uint32_t threadIndex)
111 {
112 auto bufferId = buffer->GetSeqNum();
113 auto imageCache = NativeVkImageRes::Create(buffer);
114 if (imageCache == nullptr) {
115 ROSEN_LOGE("RSVkImageManager::NewImageCacheFromBuffer: failed to create ImageCache for buffer id %{public}d.",
116 bufferId);
117 return {};
118 }
119
120 imageCache->SetThreadIndex(threadIndex);
121 imageCacheSeqs_.emplace(bufferId, imageCache);
122 cacheQueue_.push(bufferId);
123 return imageCache;
124 }
125
ShrinkCachesIfNeeded(bool isForUniRedraw)126 void RSVkImageManager::ShrinkCachesIfNeeded(bool isForUniRedraw)
127 {
128 while (cacheQueue_.size() > MAX_CACHE_SIZE) {
129 const int32_t id = cacheQueue_.front();
130 if (isForUniRedraw) {
131 UnMapVkImageFromSurfaceBufferForUniRedraw(id);
132 } else {
133 UnMapVkImageFromSurfaceBuffer(id);
134 }
135 cacheQueue_.pop();
136 }
137 }
138
UnMapVkImageFromSurfaceBuffer(int32_t seqNum)139 void RSVkImageManager::UnMapVkImageFromSurfaceBuffer(int32_t seqNum)
140 {
141 uint32_t threadIndex = UNI_MAIN_THREAD_INDEX;
142 {
143 std::lock_guard<std::mutex> lock(opMutex_);
144 if (imageCacheSeqs_.count(seqNum) == 0) {
145 return;
146 }
147 threadIndex = imageCacheSeqs_[seqNum]->GetThreadIndex();
148 }
149 auto func = [this, seqNum]() {
150 {
151 std::lock_guard<std::mutex> lock(opMutex_);
152 if (imageCacheSeqs_.count(seqNum) == 0) {
153 return;
154 }
155 (void)imageCacheSeqs_.erase(seqNum);
156 }
157 RS_LOGD("RSVkImageManager::UnMapVkImageFromSurfaceBuffer: %{public}d", seqNum);
158 };
159 if (threadIndex == UNI_MAIN_THREAD_INDEX) {
160 RSMainThread::Instance()->PostTask(func);
161 } else {
162 RSSubThreadManager::Instance()->PostTask(func, threadIndex);
163 }
164 }
165
UnMapVkImageFromSurfaceBufferForUniRedraw(int32_t seqNum)166 void RSVkImageManager::UnMapVkImageFromSurfaceBufferForUniRedraw(int32_t seqNum)
167 {
168 RSHardwareThread::Instance().PostTask([this, seqNum]() {
169 std::lock_guard<std::mutex> lock(opMutex_);
170 if (imageCacheSeqs_.count(seqNum) == 0) {
171 return;
172 }
173 (void)imageCacheSeqs_.erase(seqNum);
174 RS_LOGD("RSVkImageManager::UnMapVkImageFromSurfaceBufferForRedraw");
175 });
176 }
177
178 } // namespace Rosen
179 } // namespace OHOS