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_layer.h"
17 #include "hdi_log.h"
18 namespace OHOS {
19 namespace Rosen {
20
21 template<typename T>
Compare(const T & lhs,const T & rhs)22 bool Compare(const T& lhs, const T& rhs)
23 {
24 return lhs == rhs;
25 }
26
27 template<>
Compare(const GraphicIRect & rect1,const GraphicIRect & rect2)28 bool Compare(const GraphicIRect& rect1, const GraphicIRect& rect2)
29 {
30 return rect1.x == rect2.x && rect1.y == rect2.y && rect1.w == rect2.w && rect1.h == rect2.h;
31 }
32
33 template<typename T>
IsNeedSetInfoToDevice(const std::vector<T> & lhs,const std::vector<T> & rhs)34 bool IsNeedSetInfoToDevice(const std::vector<T>& lhs, const std::vector<T>& rhs)
35 {
36 if (lhs.size() != rhs.size()) {
37 return true;
38 }
39
40 for (decltype(lhs.size()) i = 0; i < lhs.size(); i++) {
41 if (!Compare(lhs[i], rhs[i])) {
42 return true;
43 }
44 }
45
46 return false;
47 }
48
49 /* rs create layer and set layer info begin */
CreateHdiLayer(uint32_t screenId)50 std::shared_ptr<HdiLayer> HdiLayer::CreateHdiLayer(uint32_t screenId)
51 {
52 return std::make_shared<HdiLayer>(screenId);
53 }
54
HdiLayer(uint32_t screenId)55 HdiLayer::HdiLayer(uint32_t screenId) : screenId_(screenId)
56 {
57 prevSbuffer_ = new LayerBufferInfo();
58 currSbuffer_ = new LayerBufferInfo();
59 }
60
~HdiLayer()61 HdiLayer::~HdiLayer()
62 {
63 CloseLayer();
64 }
65
Init(const LayerInfoPtr & layerInfo)66 bool HdiLayer::Init(const LayerInfoPtr &layerInfo)
67 {
68 if (layerInfo == nullptr) {
69 return false;
70 }
71
72 if (CreateLayer(layerInfo) != GRAPHIC_DISPLAY_SUCCESS) {
73 return false;
74 }
75
76 return true;
77 }
78
InitDevice()79 int32_t HdiLayer::InitDevice()
80 {
81 if (device_ != nullptr) {
82 return GRAPHIC_DISPLAY_SUCCESS;
83 }
84
85 device_ = HdiDevice::GetInstance();
86 if (device_ == nullptr) {
87 HLOGE("device_ init failed.");
88 return GRAPHIC_DISPLAY_NULL_PTR;
89 }
90 return GRAPHIC_DISPLAY_SUCCESS;
91 }
92
SetHdiDeviceMock(HdiDevice * hdiDeviceMock)93 int32_t HdiLayer::SetHdiDeviceMock(HdiDevice* hdiDeviceMock)
94 {
95 if (hdiDeviceMock == nullptr) {
96 HLOGE("Input HdiDevice is nullptr");
97 return GRAPHIC_DISPLAY_NULL_PTR;
98 }
99
100 if (device_ != nullptr) {
101 HLOGD("device_ has been initialized");
102 return GRAPHIC_DISPLAY_SUCCESS;
103 }
104
105 device_ = hdiDeviceMock;
106 return GRAPHIC_DISPLAY_SUCCESS;
107 }
108
CreateLayer(const LayerInfoPtr & layerInfo)109 int32_t HdiLayer::CreateLayer(const LayerInfoPtr &layerInfo)
110 {
111 GraphicLayerInfo hdiLayerInfo = {
112 .width = layerInfo->GetLayerSize().w,
113 .height = layerInfo->GetLayerSize().h,
114 .type = GRAPHIC_LAYER_TYPE_GRAPHIC,
115 .pixFormat = GRAPHIC_PIXEL_FMT_RGBA_8888,
116 };
117
118 int32_t retCode = InitDevice();
119 if (retCode != GRAPHIC_DISPLAY_SUCCESS) {
120 return GRAPHIC_DISPLAY_NULL_PTR;
121 }
122
123 sptr<IConsumerSurface> surface = layerInfo->GetSurface();
124 if (surface == nullptr) {
125 HLOGE("Create layer failed because the consumer surface is nullptr.");
126 return GRAPHIC_DISPLAY_NULL_PTR;
127 }
128 bufferCacheCountMax_ = surface->GetQueueSize();
129 uint32_t layerId = INT_MAX;
130 int32_t ret = device_->CreateLayer(screenId_, hdiLayerInfo, bufferCacheCountMax_, layerId);
131 if (ret != GRAPHIC_DISPLAY_SUCCESS) {
132 HLOGE("Create hwc layer failed, ret is %{public}d", ret);
133 return ret;
134 }
135 bufferCache_.clear();
136 bufferCache_.reserve(bufferCacheCountMax_);
137 layerId_ = layerId;
138
139 HLOGD("Create hwc layer succeed, layerId is %{public}u", layerId_);
140
141 CheckRet(device_->GetSupportedPresentTimestampType(screenId_, layerId_, supportedPresentTimestamptype_),
142 "GetSupportedPresentTimestamp");
143 return ret;
144 }
145
CloseLayer()146 void HdiLayer::CloseLayer()
147 {
148 if (layerId_ == INT_MAX) {
149 HLOGI("this layer has not been created");
150 return;
151 }
152
153 int32_t retCode = InitDevice();
154 if (retCode != GRAPHIC_DISPLAY_SUCCESS) {
155 return;
156 }
157
158 retCode = device_->CloseLayer(screenId_, layerId_);
159 if (retCode != GRAPHIC_DISPLAY_SUCCESS) {
160 HLOGE("Close hwc layer[%{public}u] failed, ret is %{public}d", layerId_, retCode);
161 }
162
163 HLOGD("Close hwc layer succeed, layerId is %{public}u", layerId_);
164 }
165
SetLayerAlpha()166 int32_t HdiLayer::SetLayerAlpha()
167 {
168 if (doLayerInfoCompare_) {
169 const GraphicLayerAlpha& layerAlpha1 = layerInfo_->GetAlpha();
170 const GraphicLayerAlpha& layerAlpha2 = prevLayerInfo_->GetAlpha();
171 bool isSame = layerAlpha1.enGlobalAlpha == layerAlpha2.enGlobalAlpha &&
172 layerAlpha1.enPixelAlpha == layerAlpha2.enPixelAlpha &&
173 layerAlpha1.alpha0 == layerAlpha2.alpha0 && layerAlpha1.alpha1 == layerAlpha2.alpha1 &&
174 layerAlpha1.gAlpha == layerAlpha2.gAlpha;
175 if (isSame) {
176 return GRAPHIC_DISPLAY_SUCCESS;
177 }
178 }
179
180 int32_t ret = device_->SetLayerAlpha(screenId_, layerId_, layerInfo_->GetAlpha());
181 return ret;
182 }
183
SetLayerSize()184 int32_t HdiLayer::SetLayerSize()
185 {
186 if (doLayerInfoCompare_ && Compare(layerInfo_->GetLayerSize(), prevLayerInfo_->GetLayerSize())) {
187 return GRAPHIC_DISPLAY_SUCCESS;
188 }
189
190 int32_t ret = device_->SetLayerSize(screenId_, layerId_, layerInfo_->GetLayerSize());
191 return ret;
192 }
193
SetTransformMode()194 int32_t HdiLayer::SetTransformMode()
195 {
196 if (layerInfo_->GetTransformType() == GraphicTransformType::GRAPHIC_ROTATE_BUTT || (doLayerInfoCompare_ &&
197 layerInfo_->GetTransformType() == prevLayerInfo_->GetTransformType())) {
198 return GRAPHIC_DISPLAY_SUCCESS;
199 }
200
201 GraphicTransformType transFormType = layerInfo_->GetTransformType();
202 int32_t ret = device_->SetTransformMode(screenId_, layerId_, transFormType);
203 return ret;
204 }
205
SetLayerVisibleRegion()206 int32_t HdiLayer::SetLayerVisibleRegion()
207 {
208 const std::vector<GraphicIRect>& curVisibles = layerInfo_->GetVisibleRegions();
209 bool isNeedSetInfoToDevice = true;
210 if (doLayerInfoCompare_) {
211 const std::vector<GraphicIRect>& prevVisibles = prevLayerInfo_->GetVisibleRegions();
212 if (!IsNeedSetInfoToDevice(curVisibles, prevVisibles)) {
213 isNeedSetInfoToDevice = false;
214 }
215 }
216
217 if (isNeedSetInfoToDevice) {
218 return device_->SetLayerVisibleRegion(screenId_, layerId_, curVisibles);
219 }
220
221 return GRAPHIC_DISPLAY_SUCCESS;
222 }
223
SetLayerDirtyRegion()224 int32_t HdiLayer::SetLayerDirtyRegion()
225 {
226 const std::vector<GraphicIRect>& curDirtyRegions = layerInfo_->GetDirtyRegions();
227 bool isNeedSetInfoToDevice = true;
228 if (doLayerInfoCompare_) {
229 const std::vector<GraphicIRect>& prevDirtyRegions = prevLayerInfo_->GetDirtyRegions();
230 if (!IsNeedSetInfoToDevice(curDirtyRegions, prevDirtyRegions)) {
231 isNeedSetInfoToDevice = false;
232 }
233 }
234
235 if (isNeedSetInfoToDevice) {
236 return device_->SetLayerDirtyRegion(screenId_, layerId_, curDirtyRegions);
237 }
238
239 return GRAPHIC_DISPLAY_SUCCESS;
240 }
241
CheckAndUpdateLayerBufferCahce(sptr<SurfaceBuffer> buffer,uint32_t & index,std::vector<uint32_t> & deletingList)242 bool HdiLayer::CheckAndUpdateLayerBufferCahce(sptr<SurfaceBuffer> buffer, uint32_t& index,
243 std::vector<uint32_t>& deletingList)
244 {
245 uint32_t bufferCacheSize = (uint32_t)bufferCache_.size();
246 for (uint32_t i = 0; i < bufferCacheSize; i++) {
247 if (bufferCache_[i] == buffer) {
248 index = i;
249 return true;
250 }
251 }
252
253 if (bufferCacheSize >= bufferCacheCountMax_) {
254 for (uint32_t i = 0; i < bufferCacheSize; i++) {
255 deletingList.push_back(i);
256 }
257 bufferCache_.clear();
258 }
259 index = (uint32_t)bufferCache_.size();
260 bufferCache_.push_back(buffer);
261 return false;
262 }
263
SetLayerBuffer()264 int32_t HdiLayer::SetLayerBuffer()
265 {
266 sptr<SurfaceBuffer> currBuffer = layerInfo_->GetBuffer();
267 sptr<SyncFence> currAcquireFence = layerInfo_->GetAcquireFence();
268 if (currBuffer == nullptr) {
269 return GRAPHIC_DISPLAY_SUCCESS;
270 }
271 if (doLayerInfoCompare_) {
272 sptr<SurfaceBuffer> prevBuffer = prevLayerInfo_->GetBuffer();
273 sptr<SyncFence> prevAcquireFence = prevLayerInfo_->GetAcquireFence();
274 if (currBuffer == prevBuffer && currAcquireFence == prevAcquireFence) {
275 return GRAPHIC_DISPLAY_SUCCESS;
276 }
277 }
278
279 uint32_t index = INVALID_BUFFER_CACHE_INDEX;
280 std::vector<uint32_t> deletingList = {};
281 bool bufferCached = false;
282 if (bufferCacheCountMax_ == 0) {
283 bufferCache_.clear();
284 HLOGE("The count of this layer buffer cache is 0.");
285 } else {
286 bufferCached = CheckAndUpdateLayerBufferCahce(currBuffer, index, deletingList);
287 }
288
289 GraphicLayerBuffer layerBuffer;
290 layerBuffer.cacheIndex = index;
291 layerBuffer.acquireFence = currAcquireFence;
292 layerBuffer.deletingList = deletingList;
293 if (bufferCached && index < bufferCacheCountMax_) {
294 layerBuffer.handle = nullptr;
295 } else {
296 layerBuffer.handle = currBuffer->GetBufferHandle();
297 }
298 return device_->SetLayerBuffer(screenId_, layerId_, layerBuffer);
299 }
300
SetLayerCompositionType()301 int32_t HdiLayer::SetLayerCompositionType()
302 {
303 if (doLayerInfoCompare_ && layerInfo_->GetCompositionType() == prevLayerInfo_->GetCompositionType()) {
304 return GRAPHIC_DISPLAY_SUCCESS;
305 }
306
307 int32_t ret = device_->SetLayerCompositionType(screenId_, layerId_, layerInfo_->GetCompositionType());
308 return ret;
309 }
310
SetLayerBlendType()311 int32_t HdiLayer::SetLayerBlendType()
312 {
313 if (doLayerInfoCompare_ && layerInfo_->GetBlendType() == prevLayerInfo_->GetBlendType()) {
314 return GRAPHIC_DISPLAY_SUCCESS;
315 }
316
317 int32_t ret = device_->SetLayerBlendType(screenId_, layerId_, layerInfo_->GetBlendType());
318 return ret;
319 }
320
SetLayerCrop()321 int32_t HdiLayer::SetLayerCrop()
322 {
323 if (doLayerInfoCompare_ && Compare(layerInfo_->GetCropRect(), prevLayerInfo_->GetCropRect())) {
324 return GRAPHIC_DISPLAY_SUCCESS;
325 }
326
327 int32_t ret = device_->SetLayerCrop(screenId_, layerId_, layerInfo_->GetCropRect());
328 return ret;
329 }
330
SetLayerZorder()331 int32_t HdiLayer::SetLayerZorder()
332 {
333 if (doLayerInfoCompare_ && layerInfo_->GetZorder() == prevLayerInfo_->GetZorder()) {
334 return GRAPHIC_DISPLAY_SUCCESS;
335 }
336
337 int32_t ret = device_->SetLayerZorder(screenId_, layerId_, layerInfo_->GetZorder());
338 return ret;
339 }
340
SetLayerPreMulti()341 int32_t HdiLayer::SetLayerPreMulti()
342 {
343 if (doLayerInfoCompare_ && layerInfo_->IsPreMulti() == prevLayerInfo_->IsPreMulti()) {
344 return GRAPHIC_DISPLAY_SUCCESS;
345 }
346
347 int32_t ret = device_->SetLayerPreMulti(screenId_, layerId_, layerInfo_->IsPreMulti());
348 return ret;
349 }
350
SetLayerColor()351 int32_t HdiLayer::SetLayerColor()
352 {
353 if (doLayerInfoCompare_ && layerInfo_->GetLayerColor().r == prevLayerInfo_->GetLayerColor().r
354 && layerInfo_->GetLayerColor().g == prevLayerInfo_->GetLayerColor().g
355 && layerInfo_->GetLayerColor().b == prevLayerInfo_->GetLayerColor().b
356 && layerInfo_->GetLayerColor().a == prevLayerInfo_->GetLayerColor().a) {
357 return GRAPHIC_DISPLAY_SUCCESS;
358 }
359
360 // because hdi interface func is not implemented, delete CheckRet to avoid excessive print of log
361 device_->SetLayerColor(screenId_, layerId_, layerInfo_->GetLayerColor());
362 return GRAPHIC_DISPLAY_SUCCESS;
363 }
364
SetLayerColorTransform()365 int32_t HdiLayer::SetLayerColorTransform()
366 {
367 const std::vector<float>& curMatrix = layerInfo_->GetColorTransform();
368 bool isNeedSetInfoToDevice = true;
369 if (doLayerInfoCompare_) {
370 const std::vector<float>& prevMatrix = prevLayerInfo_->GetColorTransform();
371 if (!IsNeedSetInfoToDevice(curMatrix, prevMatrix)) {
372 isNeedSetInfoToDevice = false;
373 }
374 }
375 if (isNeedSetInfoToDevice) {
376 // This method may not be supported, the return value is not check here
377 device_->SetLayerColorTransform(screenId_, layerId_, curMatrix);
378 }
379
380 return GRAPHIC_DISPLAY_SUCCESS;
381 }
382
SetLayerColorDataSpace()383 int32_t HdiLayer::SetLayerColorDataSpace()
384 {
385 if (doLayerInfoCompare_ && layerInfo_->GetColorDataSpace() == prevLayerInfo_->GetColorDataSpace()) {
386 return GRAPHIC_DISPLAY_SUCCESS;
387 }
388
389 // because hdi interface func is not implemented, delete CheckRet to avoid excessive print of log
390 device_->SetLayerColorDataSpace(screenId_, layerId_, layerInfo_->GetColorDataSpace());
391 return GRAPHIC_DISPLAY_SUCCESS;
392 }
393
IsSameLayerMetaData()394 bool HdiLayer::IsSameLayerMetaData()
395 {
396 bool isSame = false;
397 std::vector<GraphicHDRMetaData>& metaData = layerInfo_->GetMetaData();
398 std::vector<GraphicHDRMetaData>& prevMetaData = prevLayerInfo_->GetMetaData();
399 if (metaData.size() == prevMetaData.size()) {
400 isSame = true;
401 size_t metaDeataSize = metaData.size();
402 for (size_t i = 0; i < metaDeataSize; i++) {
403 if (metaData[i].key != prevMetaData[i].key || metaData[i].value != prevMetaData[i].value) {
404 isSame = false;
405 break;
406 }
407 }
408 }
409 return isSame;
410 }
411
SetLayerMetaData()412 int32_t HdiLayer::SetLayerMetaData()
413 {
414 if (doLayerInfoCompare_) {
415 bool isSame = IsSameLayerMetaData();
416 if (isSame) {
417 return GRAPHIC_DISPLAY_SUCCESS;
418 }
419 }
420
421 // because hdi interface func is not implemented, delete CheckRet to avoid excessive print of log
422 device_->SetLayerMetaData(screenId_, layerId_, layerInfo_->GetMetaData());
423 return GRAPHIC_DISPLAY_SUCCESS;
424 }
425
426
IsSameLayerMetaDataSet()427 bool HdiLayer::IsSameLayerMetaDataSet()
428 {
429 bool isSame = false;
430 GraphicHDRMetaDataSet &metaDataSet = layerInfo_->GetMetaDataSet();
431 GraphicHDRMetaDataSet &prevMetaDataSet = prevLayerInfo_->GetMetaDataSet();
432 if (metaDataSet.key == prevMetaDataSet.key &&
433 metaDataSet.metaData.size() == prevMetaDataSet.metaData.size()) {
434 isSame = true;
435 size_t metaDeataSetSize = metaDataSet.metaData.size();
436 for (size_t i = 0; i < metaDeataSetSize; i++) {
437 if (metaDataSet.metaData[i] != prevMetaDataSet.metaData[i]) {
438 isSame = false;
439 break;
440 }
441 }
442 }
443 return isSame;
444 }
445
SetLayerMetaDataSet()446 int32_t HdiLayer::SetLayerMetaDataSet()
447 {
448 if (doLayerInfoCompare_) {
449 bool isSame = IsSameLayerMetaDataSet();
450 if (isSame) {
451 return GRAPHIC_DISPLAY_SUCCESS;
452 }
453 }
454
455 // because hdi interface func is not implemented, delete CheckRet to avoid excessive print of log
456 device_->SetLayerMetaDataSet(screenId_, layerId_, layerInfo_->GetMetaDataSet().key,
457 layerInfo_->GetMetaDataSet().metaData);
458 return GRAPHIC_DISPLAY_SUCCESS;
459 }
460
SetLayerTunnelHandle()461 int32_t HdiLayer::SetLayerTunnelHandle()
462 {
463 if (!layerInfo_->GetTunnelHandleChange()) {
464 return GRAPHIC_DISPLAY_SUCCESS;
465 }
466 int32_t ret = GRAPHIC_DISPLAY_SUCCESS;
467 if (layerInfo_->GetTunnelHandle() == nullptr) {
468 ret = device_->SetLayerTunnelHandle(screenId_, layerId_, nullptr);
469 } else {
470 ret = device_->SetLayerTunnelHandle(screenId_, layerId_, layerInfo_->GetTunnelHandle()->GetHandle());
471 }
472 return ret;
473 }
474
SetLayerPresentTimestamp()475 int32_t HdiLayer::SetLayerPresentTimestamp()
476 {
477 if (supportedPresentTimestamptype_ == GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_UNSUPPORTED) {
478 return GRAPHIC_DISPLAY_SUCCESS;
479 }
480 layerInfo_->SetIsSupportedPresentTimestamp(true);
481 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_UNSUPPORTED, 0};
482 int32_t ret = device_->GetPresentTimestamp(screenId_, layerId_, timestamp);
483 GraphicPresentTimestamp graphicTimestamp = {
484 .type = static_cast<GraphicPresentTimestampType>(timestamp.type),
485 .time = timestamp.time,
486 };
487
488 CheckRet(ret, "GetPresentTimestamp");
489 if (ret == GRAPHIC_DISPLAY_SUCCESS) {
490 layerInfo_->SetPresentTimestamp(graphicTimestamp);
491 }
492 return ret;
493 }
494
SetLayerMaskInfo()495 int32_t HdiLayer::SetLayerMaskInfo()
496 {
497 return device_->SetLayerMaskInfo(screenId_, layerId_, static_cast<uint32_t>(layerInfo_->GetLayerMaskInfo()));
498 }
499
SetHdiLayerInfo()500 int32_t HdiLayer::SetHdiLayerInfo()
501 {
502 /*
503 Some hardware platforms may not support all layer settings.
504 If the current function is not supported, continue other layer settings.
505 */
506 int32_t ret = InitDevice();
507 if (ret != GRAPHIC_DISPLAY_SUCCESS || layerInfo_ == nullptr) {
508 return GRAPHIC_DISPLAY_FAILURE;
509 }
510
511 // All layer properities need to set to hwc when the layer is created firstly or the previous layer's composition
512 // type is COMPOSITION_DEVICE for COMPOSITION_DEVICE can not reuse COMPOSITION_CLIENT layers info.
513 doLayerInfoCompare_ = prevLayerInfo_ != nullptr &&
514 prevLayerInfo_->GetCompositionType() == GraphicCompositionType::GRAPHIC_COMPOSITION_DEVICE;
515
516 ret = SetLayerAlpha();
517 CheckRet(ret, "SetLayerAlpha");
518 ret = SetLayerSize();
519 CheckRet(ret, "SetLayerSize");
520 ret = SetTransformMode();
521 CheckRet(ret, "SetTransformMode");
522 ret = SetLayerVisibleRegion();
523 CheckRet(ret, "SetLayerVisibleRegion");
524 ret = SetLayerDirtyRegion();
525 CheckRet(ret, "SetLayerDirtyRegion");
526 ret = SetLayerBuffer();
527 CheckRet(ret, "SetLayerBuffer");
528 ret = SetLayerCompositionType();
529 CheckRet(ret, "SetLayerCompositionType");
530 ret = SetLayerBlendType();
531 CheckRet(ret, "SetLayerBlendType");
532 ret = SetLayerCrop();
533 CheckRet(ret, "SetLayerCrop");
534 ret = SetLayerZorder();
535 CheckRet(ret, "SetLayerZorder");
536 ret = SetLayerPreMulti();
537 CheckRet(ret, "SetLayerPreMulti");
538 ret = SetLayerColor();
539 CheckRet(ret, "SetLayerColor");
540 // This method may not be supported, the return value is not check here
541 (void)SetLayerColorTransform();
542 ret = SetLayerColorDataSpace();
543 CheckRet(ret, "SetLayerColorDataSpace");
544 ret = SetLayerMetaData();
545 CheckRet(ret, "SetLayerMetaData");
546 ret = SetLayerMetaDataSet();
547 CheckRet(ret, "SetLayerMetaDataSet");
548 ret = SetLayerTunnelHandle();
549 CheckRet(ret, "SetLayerTunnelHandle");
550 ret = SetLayerPresentTimestamp();
551 CheckRet(ret, "SetLayerPresentTimestamp");
552 ret = SetLayerMaskInfo();
553 CheckRet(ret, "SetLayerMask");
554
555 return GRAPHIC_DISPLAY_SUCCESS;
556 }
557
GetLayerId() const558 uint32_t HdiLayer::GetLayerId() const
559 {
560 return layerId_;
561 }
562
GetLayerInfo()563 const LayerInfoPtr& HdiLayer::GetLayerInfo()
564 {
565 return layerInfo_;
566 }
567
SetLayerStatus(bool inUsing)568 void HdiLayer::SetLayerStatus(bool inUsing)
569 {
570 isInUsing_ = inUsing;
571 }
572
GetLayerStatus() const573 bool HdiLayer::GetLayerStatus() const
574 {
575 return isInUsing_;
576 }
577
UpdateLayerInfo(const LayerInfoPtr & layerInfo)578 void HdiLayer::UpdateLayerInfo(const LayerInfoPtr &layerInfo)
579 {
580 if (layerInfo == nullptr) {
581 return;
582 }
583
584 /* If the layer is updated, it indicates that the layer will be used
585 * in the frame. Mark it.
586 */
587
588 isInUsing_ = true;
589 layerInfo_ = layerInfo;
590
591 prevSbuffer_->sbuffer_ = currSbuffer_->sbuffer_;
592 prevSbuffer_->acquireFence_ = currSbuffer_->acquireFence_;
593
594 currSbuffer_->sbuffer_ = layerInfo_->GetBuffer();
595 currSbuffer_->acquireFence_ = layerInfo_->GetAcquireFence();
596 }
597
GetReleaseFence() const598 sptr<SyncFence> HdiLayer::GetReleaseFence() const
599 {
600 if (currSbuffer_ == nullptr) {
601 return SyncFence::INVALID_FENCE;
602 }
603 return currSbuffer_->releaseFence_;
604 }
605
RecordPresentTime(int64_t timestamp)606 void HdiLayer::RecordPresentTime(int64_t timestamp)
607 {
608 if (currSbuffer_->sbuffer_ != prevSbuffer_->sbuffer_) {
609 presentTimeRecords[count] = timestamp;
610 count = (count + 1) % FRAME_RECORDS_NUM;
611 }
612 }
613
MergeWithFramebufferFence(const sptr<SyncFence> & fbAcquireFence)614 void HdiLayer::MergeWithFramebufferFence(const sptr<SyncFence> &fbAcquireFence)
615 {
616 if (fbAcquireFence != nullptr) {
617 currSbuffer_->releaseFence_ = Merge(currSbuffer_->releaseFence_, fbAcquireFence);
618 }
619 }
620
MergeWithLayerFence(const sptr<SyncFence> & layerReleaseFence)621 void HdiLayer::MergeWithLayerFence(const sptr<SyncFence> &layerReleaseFence)
622 {
623 if (layerReleaseFence != nullptr) {
624 currSbuffer_->releaseFence_ = Merge(currSbuffer_->releaseFence_, layerReleaseFence);
625 }
626 }
627
UpdateCompositionType(GraphicCompositionType type)628 void HdiLayer::UpdateCompositionType(GraphicCompositionType type)
629 {
630 if (layerInfo_ == nullptr) {
631 return;
632 }
633
634 layerInfo_->SetCompositionType(type);
635 }
636 /* backend get layer info end */
637
Merge(const sptr<SyncFence> & fence1,const sptr<SyncFence> & fence2)638 sptr<SyncFence> HdiLayer::Merge(const sptr<SyncFence> &fence1, const sptr<SyncFence> &fence2)
639 {
640 return SyncFence::MergeFence("ReleaseFence", fence1, fence2);
641 }
642
CheckRet(int32_t ret,const char * func)643 void HdiLayer::CheckRet(int32_t ret, const char* func)
644 {
645 if (ret != GRAPHIC_DISPLAY_SUCCESS) {
646 HLOGD("call hdi %{public}s failed, ret is %{public}d", func, ret);
647 }
648 }
649
SavePrevLayerInfo()650 void HdiLayer::SavePrevLayerInfo()
651 {
652 if (prevLayerInfo_ == nullptr) {
653 prevLayerInfo_ = HdiLayerInfo::CreateHdiLayerInfo();
654 }
655 prevLayerInfo_->CopyLayerInfo(layerInfo_);
656 }
657
Dump(std::string & result)658 void HdiLayer::Dump(std::string &result)
659 {
660 const uint32_t offset = count;
661 for (uint32_t i = 0; i < FRAME_RECORDS_NUM; i++) {
662 uint32_t order = (offset + i) % FRAME_RECORDS_NUM;
663 result += std::to_string(presentTimeRecords[order]) + "\n";
664 }
665 }
666
ClearDump()667 void HdiLayer::ClearDump()
668 {
669 presentTimeRecords.fill(0);
670 }
671
672 } // namespace Rosen
673 } // namespace OHOS
674