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 "include/core/SkColorSpace.h"
19 #include "native_buffer_inner.h"
20 #include "platform/common/rs_log.h"
21 #include "include/gpu/GrBackendSurface.h"
22 #include "pipeline/rs_hardware_thread.h"
23 #include "pipeline/rs_task_dispatcher.h"
24 #include "rs_trace.h"
25 #include "common/rs_optional_trace.h"
26 #include "params/rs_surface_render_params.h"
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
WaitAcquireFence(const sptr<SyncFence> & acquireFence)31 void WaitAcquireFence(const sptr<SyncFence>& acquireFence)
32 {
33 if (acquireFence == nullptr) {
34 return;
35 }
36 acquireFence->Wait(3000); // 3000ms
37 }
38
39 constexpr size_t MAX_CACHE_SIZE = 16;
40 }
41
~NativeVkImageRes()42 NativeVkImageRes::~NativeVkImageRes()
43 {
44 NativeBufferUtils::DeleteVkImage(mVulkanCleanupHelper);
45 DestroyNativeWindowBuffer(mNativeWindowBuffer);
46 }
47
Create(sptr<OHOS::SurfaceBuffer> buffer)48 std::shared_ptr<NativeVkImageRes> NativeVkImageRes::Create(sptr<OHOS::SurfaceBuffer> buffer)
49 {
50 if (buffer == nullptr) {
51 ROSEN_LOGE("NativeVkImageRes::Create buffer is nullptr");
52 return nullptr;
53 }
54 auto width = buffer->GetSurfaceBufferWidth();
55 auto height = buffer->GetSurfaceBufferHeight();
56 NativeWindowBuffer* nativeWindowBuffer = CreateNativeWindowBufferFromSurfaceBuffer(&buffer);
57 bool isProtected = (buffer->GetUsage() & BUFFER_USAGE_PROTECTED) != 0;
58 auto backendTexture = NativeBufferUtils::MakeBackendTextureFromNativeBuffer(nativeWindowBuffer,
59 width, height, isProtected);
60 if (!backendTexture.IsValid() || !backendTexture.GetTextureInfo().GetVKTextureInfo()) {
61 DestroyNativeWindowBuffer(nativeWindowBuffer);
62 return nullptr;
63 }
64 return std::make_unique<NativeVkImageRes>(
65 nativeWindowBuffer,
66 backendTexture,
67 new NativeBufferUtils::VulkanCleanupHelper(RsVulkanContext::GetSingleton(),
68 backendTexture.GetTextureInfo().GetVKTextureInfo()->vkImage,
69 backendTexture.GetTextureInfo().GetVKTextureInfo()->vkAlloc.memory));
70 }
71
MapVkImageFromSurfaceBuffer(const sptr<OHOS::SurfaceBuffer> & buffer,const sptr<SyncFence> & acquireFence,pid_t threadIndex)72 std::shared_ptr<NativeVkImageRes> RSVkImageManager::MapVkImageFromSurfaceBuffer(
73 const sptr<OHOS::SurfaceBuffer>& buffer,
74 const sptr<SyncFence>& acquireFence,
75 pid_t threadIndex)
76 {
77 if (buffer == nullptr) {
78 ROSEN_LOGE("RSVkImageManager::MapVkImageFromSurfaceBuffer buffer is nullptr");
79 return nullptr;
80 }
81 WaitAcquireFence(acquireFence);
82 std::lock_guard<std::mutex> lock(opMutex_);
83 auto bufferId = buffer->GetSeqNum();
84 if (imageCacheSeqs_.find(bufferId) == imageCacheSeqs_.end() || (buffer->GetUsage() & BUFFER_USAGE_PROTECTED)) {
85 return NewImageCacheFromBuffer(buffer, threadIndex);
86 } else {
87 return imageCacheSeqs_[bufferId];
88 }
89 }
90
CreateImageCacheFromBuffer(sptr<OHOS::SurfaceBuffer> buffer,const sptr<SyncFence> & acquireFence)91 std::shared_ptr<NativeVkImageRes> RSVkImageManager::CreateImageCacheFromBuffer(sptr<OHOS::SurfaceBuffer> buffer,
92 const sptr<SyncFence>& acquireFence)
93 {
94 WaitAcquireFence(acquireFence);
95 auto bufferId = buffer->GetSeqNum();
96 auto imageCache = NativeVkImageRes::Create(buffer);
97 if (imageCache == nullptr) {
98 ROSEN_LOGE(
99 "RSVkImageManager::CreateImageCacheFromBuffer: failed to create ImageCache for buffer id %{public}d.",
100 bufferId);
101 return nullptr;
102 }
103 return imageCache;
104 }
105
NewImageCacheFromBuffer(const sptr<OHOS::SurfaceBuffer> & buffer,pid_t threadIndex)106 std::shared_ptr<NativeVkImageRes> RSVkImageManager::NewImageCacheFromBuffer(
107 const sptr<OHOS::SurfaceBuffer>& buffer, pid_t threadIndex)
108 {
109 auto bufferId = buffer->GetSeqNum();
110 auto imageCache = NativeVkImageRes::Create(buffer);
111 if (imageCache == nullptr) {
112 ROSEN_LOGE("RSVkImageManager::NewImageCacheFromBuffer: failed to create ImageCache for buffer id %{public}d.",
113 bufferId);
114 return {};
115 }
116
117 imageCache->SetThreadIndex(threadIndex);
118 if (buffer->GetUsage() & BUFFER_USAGE_PROTECTED) {
119 return imageCache;
120 }
121 imageCacheSeqs_.emplace(bufferId, imageCache);
122 cacheQueue_.push(bufferId);
123 return imageCache;
124 }
125
ShrinkCachesIfNeeded()126 void RSVkImageManager::ShrinkCachesIfNeeded()
127 {
128 while (cacheQueue_.size() > MAX_CACHE_SIZE) {
129 const int32_t id = cacheQueue_.front();
130 UnMapVkImageFromSurfaceBuffer(id);
131 cacheQueue_.pop();
132 }
133 }
134
UnMapVkImageFromSurfaceBuffer(int32_t seqNum)135 void RSVkImageManager::UnMapVkImageFromSurfaceBuffer(int32_t seqNum)
136 {
137 pid_t threadIndex = UNI_RENDER_THREAD_INDEX;
138 {
139 std::lock_guard<std::mutex> lock(opMutex_);
140 if (imageCacheSeqs_.count(seqNum) == 0) {
141 return;
142 }
143 threadIndex = imageCacheSeqs_[seqNum]->GetThreadIndex();
144 }
145 auto func = [this, seqNum, threadIndex]() {
146 {
147 std::lock_guard<std::mutex> lock(opMutex_);
148 if (imageCacheSeqs_.count(seqNum) == 0) {
149 return;
150 }
151 (void)imageCacheSeqs_.erase(seqNum);
152 }
153 };
154 RSTaskDispatcher::GetInstance().PostTask(threadIndex, func);
155 }
156
157 } // namespace Rosen
158 } // namespace OHOS