1 /*
2 * Copyright (c) 2021 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 "hdi_display.h"
17 #include <vector>
18 #include "display_common.h"
19
20 namespace OHOS {
21 namespace HDI {
22 namespace DISPLAY {
23 uint32_t HdiDisplay::mIdleId = 0;
24 std::unordered_set<uint32_t> HdiDisplay::mIdSets;
25
GetIdleId()26 uint32_t HdiDisplay::GetIdleId()
27 {
28 const uint32_t oldIdleId = mIdleId;
29 uint32_t id = INVALIDE_DISPLAY_ID;
30 // ensure the mIdleId not INVALIDE_DISPLAY_ID
31 mIdleId = mIdleId % INVALIDE_DISPLAY_ID;
32 do {
33 auto iter = mIdSets.find(mIdleId);
34 if (iter == mIdSets.end()) {
35 id = mIdleId;
36 break;
37 }
38 mIdleId = (mIdleId + 1) % INVALIDE_DISPLAY_ID;
39 } while (oldIdleId != mIdleId);
40 mIdSets.emplace(id);
41 mIdleId++;
42 return id;
43 }
44
45
Init()46 int32_t HdiDisplay::Init()
47 {
48 DISPLAY_LOGD();
49 uint32_t id = GetIdleId();
50 DISPLAY_CHK_RETURN((id == INVALIDE_DISPLAY_ID), DISPLAY_FAILURE, DISPLAY_LOGE("have no id to used"));
51 mId = id;
52 auto layer = CreateHdiLayer(LAYER_TYPE_GRAPHIC);
53 DISPLAY_CHK_RETURN((layer.get() == nullptr), DISPLAY_FAILURE, DISPLAY_LOGE("can not create hdi layer for client"));
54 mClientLayer = std::move(layer);
55 DISPLAY_LOGD("the id is %{public}d", id);
56 return DISPLAY_SUCCESS;
57 }
58
59
~HdiDisplay()60 HdiDisplay::~HdiDisplay()
61 {
62 mIdSets.erase(mId);
63 }
64
SetLayerZorder(uint32_t layerId,uint32_t zorder)65 int32_t HdiDisplay::SetLayerZorder(uint32_t layerId, uint32_t zorder)
66 {
67 DISPLAY_LOGD("layerId:%{public}d zorder:%{public}d size:%{public}zu", layerId, zorder, mLayers.size());
68 auto iter = mLayersMap.find(layerId);
69 DISPLAY_CHK_RETURN((iter == mLayersMap.end()), DISPLAY_FAILURE,
70 DISPLAY_LOGE("can not find the layer %{public}d", layerId));
71 auto layer = mLayersMap[layerId].get();
72 if (layer->GetZorder() == zorder) {
73 DISPLAY_LOGD("zorder no change layerId %{public}d, zorder %{public}d", layerId, zorder);
74 return DISPLAY_SUCCESS;
75 }
76 // reset to sort
77 auto zRange = mLayers.equal_range(layer);
78 for (auto c = zRange.first; c != zRange.second; c++) {
79 if (*c == layer) {
80 mLayers.erase(c);
81 break;
82 }
83 }
84 layer->SetLayerZorder(zorder);
85 mLayers.emplace(layer);
86 DISPLAY_LOGD("SetLayerZorder size:%{public}zu", mLayers.size());
87 return DISPLAY_SUCCESS;
88 }
89
CreateLayer(const LayerInfo * layerInfo,uint32_t * layerId)90 int32_t HdiDisplay::CreateLayer(const LayerInfo *layerInfo, uint32_t *layerId)
91 {
92 DISPLAY_LOGD();
93 int ret;
94 DISPLAY_CHK_RETURN((layerInfo == nullptr), DISPLAY_PARAM_ERR, DISPLAY_LOGE("LayerInfo is null"));
95 DISPLAY_CHK_RETURN((layerId == nullptr), DISPLAY_PARAM_ERR, DISPLAY_LOGE("layerId is null"));
96 auto layer = CreateHdiLayer(layerInfo->type);
97 DISPLAY_CHK_RETURN((layer.get() == nullptr), DISPLAY_FAILURE, DISPLAY_LOGE("can not create hdi layer"));
98 ret = layer->Init();
99 DISPLAY_CHK_RETURN((ret != DISPLAY_SUCCESS), DISPLAY_FAILURE, DISPLAY_LOGE("Layer Init failed"));
100 *layerId = layer->GetId();
101 mLayers.insert(layer.get());
102 mLayersMap.emplace(layer->GetId(), std::move(layer));
103 DISPLAY_LOGD("mLayers size %{public}zu", mLayers.size());
104 DISPLAY_LOGD("mLayerMap size %{public}zu", mLayersMap.size());
105 return DISPLAY_SUCCESS;
106 }
107
CreateHdiLayer(LayerType type)108 std::unique_ptr<HdiLayer> HdiDisplay::CreateHdiLayer(LayerType type)
109 {
110 DISPLAY_LOGD();
111 return std::make_unique<HdiLayer>(type);
112 }
113
114
CloseLayer(uint32_t layerId)115 int32_t HdiDisplay::CloseLayer(uint32_t layerId)
116 {
117 DISPLAY_LOGD("layerId %{public}d", layerId);
118 auto iter = mLayersMap.find(layerId);
119 DISPLAY_CHK_RETURN((iter == mLayersMap.end()), DISPLAY_FAILURE,
120 DISPLAY_LOGE("can not find the layer id %{public}d", layerId));
121 auto layer = iter->second.get();
122 auto zRange = mLayers.equal_range(layer);
123 for (auto c = zRange.first; c != zRange.second; c++) {
124 if (*c == layer) {
125 mLayers.erase(c);
126 break;
127 }
128 }
129 mLayersMap.erase(layerId);
130 return DISPLAY_SUCCESS;
131 }
132
GetDisplayCompChange(uint32_t * num,uint32_t * layers,int32_t * type)133 int32_t HdiDisplay::GetDisplayCompChange(uint32_t *num, uint32_t *layers, int32_t *type)
134 {
135 DISPLAY_CHK_RETURN((num == nullptr), DISPLAY_FAILURE, DISPLAY_LOGE("the num is nullptr"));
136 *num = mChangeLayers.size();
137 if ((layers == nullptr) && (type == nullptr)) {
138 return DISPLAY_SUCCESS;
139 }
140 DISPLAY_LOGD("set the layers and type");
141 for (uint32_t i = 0; i < mChangeLayers.size(); i++) {
142 HdiLayer *layer = mChangeLayers[i];
143 if (layers != nullptr) {
144 *(layers + i) = layer->GetId();
145 }
146 if (type != nullptr) {
147 *(type + i) = layer->GetCompositionType();
148 }
149 }
150 return DISPLAY_SUCCESS;
151 }
152
GetDisplayReleaseFence(uint32_t * num,uint32_t * layers,int32_t * fences)153 int32_t HdiDisplay::GetDisplayReleaseFence(uint32_t *num, uint32_t *layers, int32_t *fences)
154 {
155 DISPLAY_CHK_RETURN((num == nullptr), DISPLAY_FAILURE, DISPLAY_LOGE("the num is nullptr"));
156 *num = mLayers.size();
157 if ((layers == nullptr) && (fences == nullptr)) {
158 return DISPLAY_SUCCESS;
159 }
160 DISPLAY_LOGD("set the layer fences");
161 int i = 0;
162 for (auto layer : mLayers) {
163 if (layers != nullptr) {
164 *(layers + i) = layer->GetId();
165 }
166 if (fences != nullptr) {
167 *(fences + i) = layer->GetReleaseFenceFd();
168 }
169 DISPLAY_LOGD("layer id %{public}d fencefd %{public}d", layer->GetId(), layer->GetReleaseFenceFd());
170 i++;
171 }
172 return DISPLAY_SUCCESS;
173 }
174
PrepareDisplayLayers(bool * needFlushFb)175 int32_t HdiDisplay::PrepareDisplayLayers(bool *needFlushFb)
176 {
177 DISPLAY_LOGD();
178 mChangeLayers.clear();
179 std::vector<HdiLayer *> layers;
180 for (auto c : mLayers) {
181 if (c->IsVisible()) {
182 layers.push_back(c);
183 }
184 }
185 DISPLAY_LOGD(" mLayers size %{public}zu layers size %{public}zu", mLayers.size(), layers.size());
186
187 mComposer->Prepare(layers, *mClientLayer);
188 // get the change layers
189 for (auto &layer : layers) {
190 if (layer->GetDeviceSelect() != layer->GetCompositionType()) {
191 DISPLAY_LOGD("layer change");
192 layer->SetLayerCompositionType(layer->GetDeviceSelect());
193 mChangeLayers.push_back(layer);
194 }
195 }
196 *needFlushFb = true;
197 return DISPLAY_SUCCESS;
198 }
199
Commit(int32_t * fence)200 int32_t HdiDisplay::Commit(int32_t *fence)
201 {
202 DISPLAY_LOGD();
203 mComposer->Commit(false);
204 *fence = mClientLayer->GetReleaseFenceFd();
205 DISPLAY_LOGD("the release fence is %{public}d", *fence);
206 return DISPLAY_SUCCESS;
207 }
208
SetDisplayClientBuffer(const BufferHandle * buffer,int32_t fence)209 int32_t HdiDisplay::SetDisplayClientBuffer(const BufferHandle *buffer, int32_t fence)
210 {
211 mClientLayer->SetLayerBuffer(buffer, fence);
212 return DISPLAY_SUCCESS;
213 }
214
GetHdiLayer(uint32_t id)215 HdiLayer *HdiDisplay::GetHdiLayer(uint32_t id)
216 {
217 DISPLAY_LOGD("id : %{public}d", id);
218 auto iter = mLayersMap.find(id);
219 DISPLAY_CHK_RETURN((iter == mLayersMap.end()), nullptr, DISPLAY_LOGE("can not find the layer %{public}d", id));
220 return iter->second.get();
221 }
222
VsyncCallBack(VBlankCallback cb,void * data)223 VsyncCallBack::VsyncCallBack(VBlankCallback cb, void *data) : mVBlankCb(cb), mData(data)
224 {
225 DISPLAY_LOGD("VsyncCallBack");
226 }
227
Vsync(unsigned int sequence,uint64_t ns)228 void VsyncCallBack::Vsync(unsigned int sequence, uint64_t ns)
229 {
230 DISPLAY_CHK_RETURN_NOT_VALUE((mVBlankCb == nullptr), DISPLAY_LOGE("the callback is nullptr"));
231 mVBlankCb(sequence, ns, mData);
232 }
233 }
234 }
235 }
236