1 /*
2 * Copyright (c) 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 "device_cache.h"
17
18 #include "buffer_cache_utils.h"
19 #include "common/include/display_interface_utils.h"
20 #include "hdf_base.h"
21 #include "hdf_log.h"
22
23 namespace OHOS {
24 namespace HDI {
25 namespace Display {
26 namespace Composer {
27
Create(uint32_t id,DeviceType type)28 DeviceCache* DeviceCache::Create(uint32_t id, DeviceType type)
29 {
30 DeviceCache* device = new DeviceCache(id, type);
31 DISPLAY_CHK_RETURN(device == nullptr, nullptr, HDF_LOGE("%{public}s: create device cache failed", __func__));
32
33 int32_t ret = device->Init();
34 if (ret != HDF_SUCCESS) {
35 delete device;
36 device = nullptr;
37 HDF_LOGE("%{public}s: device cache init failed", __func__);
38 }
39
40 return device;
41 }
42
DeviceCache(uint32_t id,DeviceType type)43 DeviceCache::DeviceCache(uint32_t id, DeviceType type) : deviceId_(id), cacheType_(type)
44 {
45 }
46
~DeviceCache()47 DeviceCache::~DeviceCache()
48 {
49 }
50
Init()51 int32_t DeviceCache::Init()
52 {
53 layerCaches_.reset(new CacheManager<uint32_t, LayerCache>());
54 DISPLAY_CHK_RETURN(layerCaches_ == nullptr, HDF_FAILURE,
55 HDF_LOGE("%{public}s: create layer caches failed", __func__));
56
57 clientBufferCaches_.reset(new CacheManager<uint32_t, NativeBuffer>());
58 DISPLAY_CHK_RETURN(clientBufferCaches_ == nullptr, HDF_FAILURE,
59 HDF_LOGE("%{public}s: create client buffer caches failed", __func__));
60
61 outputBufferCaches_.reset(new CacheManager<uint32_t, NativeBuffer>());
62 DISPLAY_CHK_RETURN(outputBufferCaches_ == nullptr, HDF_FAILURE,
63 HDF_LOGE("%{public}s: create output buffer caches failed", __func__));
64
65 return HDF_SUCCESS;
66 }
67
SetClientBufferCacheCount(uint32_t bufferCacheCount)68 int32_t DeviceCache::SetClientBufferCacheCount(uint32_t bufferCacheCount)
69 {
70 return clientBufferCaches_->SetCacheMaxCount(bufferCacheCount) ? HDF_SUCCESS : HDF_FAILURE;
71 }
72
LayerCacheInstance(uint32_t layerId) const73 LayerCache* DeviceCache::LayerCacheInstance(uint32_t layerId) const
74 {
75 return layerCaches_->SearchCache(layerId);
76 }
77
AddLayerCache(uint32_t id,uint32_t bufferCacheCount)78 int32_t DeviceCache::AddLayerCache(uint32_t id, uint32_t bufferCacheCount)
79 {
80 LayerCache* layer = LayerCache::Create(id);
81 DISPLAY_CHK_RETURN(layer == nullptr, HDF_FAILURE, HDF_LOGE("%{public}s: Create cache failed", __func__));
82
83 int32_t retResult = layer->SetBufferCacheMaxCount(bufferCacheCount);
84 DISPLAY_CHK_RETURN(retResult != HDF_SUCCESS, retResult,
85 HDF_LOGE("%{public}s: set buffer cache max count failed", __func__));
86
87 bool ret = layerCaches_->InsertCache(id, layer);
88 DISPLAY_CHK_RETURN(ret != true, HDF_FAILURE, HDF_LOGE("%{public}s: insert cache failed", __func__));
89 return HDF_SUCCESS;
90 }
91
RemoveLayerCache(uint32_t id)92 int32_t DeviceCache::RemoveLayerCache(uint32_t id)
93 {
94 bool ret = layerCaches_->EraseCache(id);
95 DISPLAY_CHK_RETURN(ret != true, HDF_FAILURE, HDF_LOGE("%{public}s: Destroy cache failed", __func__));
96
97 return HDF_SUCCESS;
98 }
99
SetDisplayClientBuffer(const BufferHandle * buffer,uint32_t seqNo,bool & needFreeBuffer,std::function<int32_t (const BufferHandle &)> realFunc)100 int32_t DeviceCache::SetDisplayClientBuffer(const BufferHandle* buffer, uint32_t seqNo, bool &needFreeBuffer,
101 std::function<int32_t (const BufferHandle&)> realFunc)
102 {
103 BufferHandle* handle = BufferCacheUtils::NativeBufferCache(clientBufferCaches_,
104 const_cast<BufferHandle*>(buffer), seqNo, deviceId_, needFreeBuffer);
105 DISPLAY_CHK_RETURN(handle == nullptr, HDF_FAILURE,
106 HDF_LOGE("%{public}s: call NativeBufferCache fail", __func__));
107 auto ret = realFunc(*handle);
108 DISPLAY_CHK_RETURN(ret != HDF_SUCCESS, ret, HDF_LOGE("%{public}s: call realFunc fail", __func__));
109
110 return ret;
111 }
112
SetVirtualDisplayBuffer(const BufferHandle * buffer,uint32_t seqNo,bool & needFreeBuffer,std::function<int32_t (const BufferHandle &)> realFunc)113 int32_t DeviceCache::SetVirtualDisplayBuffer(const BufferHandle* buffer, uint32_t seqNo, bool &needFreeBuffer,
114 std::function<int32_t (const BufferHandle&)> realFunc)
115 {
116 int32_t ret = HDF_FAILURE;
117 if (CacheType() == DEVICE_TYPE_VIRTUAL) {
118 BufferHandle* handle = BufferCacheUtils::NativeBufferCache(outputBufferCaches_,
119 const_cast<BufferHandle*>(buffer), seqNo, deviceId_, needFreeBuffer);
120 DISPLAY_CHK_RETURN(handle == nullptr, HDF_FAILURE,
121 HDF_LOGE("%{public}s: call NativeBufferCache fail", __func__));
122 ret = realFunc(*handle);
123 DISPLAY_CHK_RETURN(ret != HDF_SUCCESS, ret, HDF_LOGE("%{public}s: call realFunc fail", __func__));
124 } else {
125 HDF_LOGE("%{public}s: not a virtual display", __func__);
126 }
127
128 return ret;
129 }
130
CacheType() const131 DeviceCache::DeviceType DeviceCache::CacheType() const
132 {
133 return cacheType_;
134 }
135
Dump() const136 void DeviceCache::Dump() const
137 {
138 clientBufferCaches_->TravelCaches([this](int32_t id, const NativeBuffer& buffer)->void {
139 auto info = buffer.Dump();
140 HDF_LOGE("devId-%{public}d, clientBuffer[%{public}d]: %{public}s", deviceId_, id, info.c_str());
141 });
142 outputBufferCaches_->TravelCaches([this](int32_t id, const NativeBuffer& buffer)->void {
143 auto info = buffer.Dump();
144 HDF_LOGE("devId-%{public}d, outputBuffer[%{public}d]: %{public}s", deviceId_, id, info.c_str());
145 });
146 layerCaches_->TravelCaches([](int32_t id, const LayerCache& cache)->void {
147 cache.Dump();
148 });
149 }
150 } // namespace Composer
151 } // namespace Display
152 } // namespace HDI
153 } // namespace OHOS
154