1 /*
2 * Copyright (c) 2014-2017, 2019, The Linux Foundation. All rights reserved.
3 * Not a Contribution.
4 *
5 * Copyright 2015 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20 #include <stdint.h>
21 #include <qdMetaData.h>
22
23 #include "hwc_layers.h"
24 #ifndef USE_GRALLOC1
25 #include <gr.h>
26 #endif
27 #include <utils/debug.h>
28 #include <cmath>
29
30 #define __CLASS__ "HWCLayer"
31
32 namespace sdm {
33
34 std::atomic<hwc2_layer_t> HWCLayer::next_id_(1);
35
36 // Layer operations
HWCLayer(hwc2_display_t display_id,HWCBufferAllocator * buf_allocator)37 HWCLayer::HWCLayer(hwc2_display_t display_id, HWCBufferAllocator *buf_allocator)
38 : id_(next_id_++), display_id_(display_id), buffer_allocator_(buf_allocator) {
39 layer_ = new Layer();
40 layer_->input_buffer = new LayerBuffer();
41 // Fences are deferred, so the first time this layer is presented, return -1
42 // TODO(user): Verify that fences are properly obtained on suspend/resume
43 release_fences_.push(-1);
44 }
45
~HWCLayer()46 HWCLayer::~HWCLayer() {
47 // Close any fences left for this layer
48 while (!release_fences_.empty()) {
49 close(release_fences_.front());
50 release_fences_.pop();
51 }
52 close(ion_fd_);
53 if (layer_) {
54 if (layer_->input_buffer) {
55 delete (layer_->input_buffer);
56 }
57 delete layer_;
58 }
59 }
60
SetLayerBuffer(buffer_handle_t buffer,int32_t acquire_fence)61 HWC2::Error HWCLayer::SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence) {
62 if (!buffer) {
63 DLOGE("Invalid buffer handle: %p on layer: %d", buffer, id_);
64 return HWC2::Error::BadParameter;
65 }
66
67 if (acquire_fence == 0) {
68 DLOGE("acquire_fence is zero");
69 return HWC2::Error::BadParameter;
70 }
71
72 const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
73
74 // Validate and dup ion fd from surfaceflinger
75 // This works around bug 30281222
76 if (handle->fd < 0) {
77 return HWC2::Error::BadParameter;
78 } else {
79 close(ion_fd_);
80 ion_fd_ = dup(handle->fd);
81 }
82
83 LayerBuffer *layer_buffer = layer_->input_buffer;
84 int aligned_width, aligned_height;
85 #ifdef USE_GRALLOC1
86 buffer_allocator_->GetCustomWidthAndHeight(handle, &aligned_width, &aligned_height);
87 #else
88 AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(handle, aligned_width, aligned_height);
89 #endif
90
91 LayerBufferFormat format = GetSDMFormat(handle->format, handle->flags);
92 if ((format != layer_buffer->format) || (UINT32(aligned_width) != layer_buffer->width) ||
93 (UINT32(aligned_height) != layer_buffer->height)) {
94 // Layer buffer geometry has changed.
95 geometry_changes_ |= kBufferGeometry;
96 }
97
98 layer_buffer->format = format;
99 layer_buffer->width = UINT32(aligned_width);
100 layer_buffer->height = UINT32(aligned_height);
101
102 if (SetMetaData(const_cast<private_handle_t *>(handle), layer_) != kErrorNone) {
103 return HWC2::Error::BadLayer;
104 }
105
106 layer_buffer->flags.video = (handle->buffer_type == BUFFER_TYPE_VIDEO) ? true : false;
107
108 // TZ Protected Buffer - L1
109 bool secure = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER);
110 bool secure_display = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY);
111 if (secure != layer_buffer->flags.secure ||
112 secure_display != layer_buffer->flags.secure_display) {
113 // Secure attribute of layer buffer has changed.
114 needs_validate_ = true;
115 }
116
117 layer_buffer->flags.secure = secure;
118 // layer_buffer->flags.secure_camera = secure_camera;
119 layer_buffer->flags.secure_display = secure_display;
120
121 layer_buffer->planes[0].fd = ion_fd_;
122 layer_buffer->planes[0].offset = handle->offset;
123 layer_buffer->planes[0].stride = UINT32(handle->width);
124 layer_buffer->acquire_fence_fd = acquire_fence;
125 layer_buffer->buffer_id = reinterpret_cast<uint64_t>(handle);
126
127 return HWC2::Error::None;
128 }
129
SetLayerSurfaceDamage(hwc_region_t damage)130 HWC2::Error HWCLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
131 surface_updated_ = true;
132 if ((damage.numRects == 1) && (damage.rects[0].bottom == 0) && (damage.rects[0].right == 0)) {
133 surface_updated_ = false;
134 }
135
136 if (!layer_->flags.updating && surface_updated_) {
137 needs_validate_ = true;
138 }
139
140 if (!partial_update_enabled_) {
141 SetDirtyRegions(damage);
142 return HWC2::Error::None;
143 }
144
145 // Check if there is an update in SurfaceDamage rects.
146 if (layer_->dirty_regions.size() != damage.numRects) {
147 needs_validate_ = true;
148 } else {
149 for (uint32_t j = 0; j < damage.numRects; j++) {
150 LayerRect damage_rect;
151 SetRect(damage.rects[j], &damage_rect);
152 if (damage_rect != layer_->dirty_regions.at(j)) {
153 needs_validate_ = true;
154 break;
155 }
156 }
157 }
158
159 SetDirtyRegions(damage);
160 return HWC2::Error::None;
161 }
162
SetLayerBlendMode(HWC2::BlendMode mode)163 HWC2::Error HWCLayer::SetLayerBlendMode(HWC2::BlendMode mode) {
164 LayerBlending blending = kBlendingPremultiplied;
165 switch (mode) {
166 case HWC2::BlendMode::Coverage:
167 blending = kBlendingCoverage;
168 break;
169 case HWC2::BlendMode::Premultiplied:
170 blending = kBlendingPremultiplied;
171 break;
172 case HWC2::BlendMode::None:
173 blending = kBlendingOpaque;
174 break;
175 default:
176 return HWC2::Error::BadParameter;
177 }
178
179 if (layer_->blending != blending) {
180 geometry_changes_ |= kBlendMode;
181 layer_->blending = blending;
182 }
183 return HWC2::Error::None;
184 }
185
SetLayerColor(hwc_color_t color)186 HWC2::Error HWCLayer::SetLayerColor(hwc_color_t color) {
187 layer_->solid_fill_color = GetUint32Color(color);
188 layer_->input_buffer->format = kFormatARGB8888;
189 DLOGV_IF(kTagCompManager, "[%" PRIu64 "][%" PRIu64 "] Layer color set to %x", display_id_, id_,
190 layer_->solid_fill_color);
191 return HWC2::Error::None;
192 }
193
SetLayerCompositionType(HWC2::Composition type)194 HWC2::Error HWCLayer::SetLayerCompositionType(HWC2::Composition type) {
195 // Validation is required when the client changes the composition type
196 if (client_requested_ != type) {
197 needs_validate_ = true;
198 }
199 client_requested_ = type;
200 switch (type) {
201 case HWC2::Composition::Client:
202 break;
203 case HWC2::Composition::Device:
204 // We try and default to this in SDM
205 break;
206 case HWC2::Composition::SolidColor:
207 break;
208 case HWC2::Composition::Cursor:
209 break;
210 case HWC2::Composition::Invalid:
211 return HWC2::Error::BadParameter;
212 default:
213 return HWC2::Error::Unsupported;
214 }
215
216 return HWC2::Error::None;
217 }
218
SetLayerDataspace(int32_t dataspace)219 HWC2::Error HWCLayer::SetLayerDataspace(int32_t dataspace) {
220 if (dataspace != dataspace_) {
221 dataspace_ = dataspace;
222 geometry_changes_ |= kDataspace;
223 }
224 return HWC2::Error::None;
225 }
226
SetLayerDisplayFrame(hwc_rect_t frame)227 HWC2::Error HWCLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
228 LayerRect dst_rect = {};
229 SetRect(frame, &dst_rect);
230 if (layer_->dst_rect != dst_rect) {
231 geometry_changes_ |= kDisplayFrame;
232 layer_->dst_rect = dst_rect;
233 }
234 return HWC2::Error::None;
235 }
236
SetLayerPlaneAlpha(float alpha)237 HWC2::Error HWCLayer::SetLayerPlaneAlpha(float alpha) {
238 // Conversion of float alpha in range 0.0 to 1.0 similar to the HWC Adapter
239 uint8_t plane_alpha = static_cast<uint8_t>(std::round(255.0f * alpha));
240 if (layer_->plane_alpha != plane_alpha) {
241 geometry_changes_ |= kPlaneAlpha;
242 layer_->plane_alpha = plane_alpha;
243 }
244
245 return HWC2::Error::None;
246 }
247
SetLayerSourceCrop(hwc_frect_t crop)248 HWC2::Error HWCLayer::SetLayerSourceCrop(hwc_frect_t crop) {
249 LayerRect src_rect = {};
250 SetRect(crop, &src_rect);
251 if (layer_->src_rect != src_rect) {
252 geometry_changes_ |= kSourceCrop;
253 layer_->src_rect = src_rect;
254 }
255
256 return HWC2::Error::None;
257 }
258
SetLayerTransform(HWC2::Transform transform)259 HWC2::Error HWCLayer::SetLayerTransform(HWC2::Transform transform) {
260 LayerTransform layer_transform = {};
261 switch (transform) {
262 case HWC2::Transform::FlipH:
263 layer_transform.flip_horizontal = true;
264 break;
265 case HWC2::Transform::FlipV:
266 layer_transform.flip_vertical = true;
267 break;
268 case HWC2::Transform::Rotate90:
269 layer_transform.rotation = 90.0f;
270 break;
271 case HWC2::Transform::Rotate180:
272 layer_transform.flip_horizontal = true;
273 layer_transform.flip_vertical = true;
274 break;
275 case HWC2::Transform::Rotate270:
276 layer_transform.rotation = 90.0f;
277 layer_transform.flip_horizontal = true;
278 layer_transform.flip_vertical = true;
279 break;
280 case HWC2::Transform::FlipHRotate90:
281 layer_transform.rotation = 90.0f;
282 layer_transform.flip_horizontal = true;
283 break;
284 case HWC2::Transform::FlipVRotate90:
285 layer_transform.rotation = 90.0f;
286 layer_transform.flip_vertical = true;
287 break;
288 case HWC2::Transform::None:
289 // do nothing
290 break;
291 }
292
293 if (layer_->transform != layer_transform) {
294 geometry_changes_ |= kTransform;
295 layer_->transform = layer_transform;
296 }
297 return HWC2::Error::None;
298 }
299
SetLayerVisibleRegion(hwc_region_t visible)300 HWC2::Error HWCLayer::SetLayerVisibleRegion(hwc_region_t visible) {
301 layer_->visible_regions.clear();
302 for (uint32_t i = 0; i < visible.numRects; i++) {
303 LayerRect rect;
304 SetRect(visible.rects[i], &rect);
305 layer_->visible_regions.push_back(rect);
306 }
307
308 return HWC2::Error::None;
309 }
310
SetLayerZOrder(uint32_t z)311 HWC2::Error HWCLayer::SetLayerZOrder(uint32_t z) {
312 if (z_ != z) {
313 geometry_changes_ |= kZOrder;
314 z_ = z;
315 }
316 return HWC2::Error::None;
317 }
318
SetRect(const hwc_rect_t & source,LayerRect * target)319 void HWCLayer::SetRect(const hwc_rect_t &source, LayerRect *target) {
320 target->left = FLOAT(source.left);
321 target->top = FLOAT(source.top);
322 target->right = FLOAT(source.right);
323 target->bottom = FLOAT(source.bottom);
324 }
325
SetRect(const hwc_frect_t & source,LayerRect * target)326 void HWCLayer::SetRect(const hwc_frect_t &source, LayerRect *target) {
327 // Recommended way of rounding as in hwcomposer2.h - SetLayerSourceCrop
328 target->left = std::ceil(source.left);
329 target->top = std::ceil(source.top);
330 target->right = std::floor(source.right);
331 target->bottom = std::floor(source.bottom);
332 }
333
GetUint32Color(const hwc_color_t & source)334 uint32_t HWCLayer::GetUint32Color(const hwc_color_t &source) {
335 // Returns 32 bit ARGB
336 uint32_t a = UINT32(source.a) << 24;
337 uint32_t r = UINT32(source.r) << 16;
338 uint32_t g = UINT32(source.g) << 8;
339 uint32_t b = UINT32(source.b);
340 uint32_t color = a | r | g | b;
341 return color;
342 }
343
GetSDMFormat(const int32_t & source,const int flags)344 LayerBufferFormat HWCLayer::GetSDMFormat(const int32_t &source, const int flags) {
345 LayerBufferFormat format = kFormatInvalid;
346 if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
347 switch (source) {
348 case HAL_PIXEL_FORMAT_RGBA_8888:
349 format = kFormatRGBA8888Ubwc;
350 break;
351 case HAL_PIXEL_FORMAT_RGBX_8888:
352 format = kFormatRGBX8888Ubwc;
353 break;
354 case HAL_PIXEL_FORMAT_BGR_565:
355 format = kFormatBGR565Ubwc;
356 break;
357 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
358 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
359 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
360 format = kFormatYCbCr420SPVenusUbwc;
361 break;
362 case HAL_PIXEL_FORMAT_RGBA_1010102:
363 format = kFormatRGBA1010102Ubwc;
364 break;
365 case HAL_PIXEL_FORMAT_RGBX_1010102:
366 format = kFormatRGBX1010102Ubwc;
367 break;
368 default:
369 DLOGE("Unsupported format type for UBWC %d", source);
370 return kFormatInvalid;
371 }
372 return format;
373 }
374
375 switch (source) {
376 case HAL_PIXEL_FORMAT_RGBA_8888:
377 format = kFormatRGBA8888;
378 break;
379 case HAL_PIXEL_FORMAT_RGBA_5551:
380 format = kFormatRGBA5551;
381 break;
382 case HAL_PIXEL_FORMAT_RGBA_4444:
383 format = kFormatRGBA4444;
384 break;
385 case HAL_PIXEL_FORMAT_BGRA_8888:
386 format = kFormatBGRA8888;
387 break;
388 case HAL_PIXEL_FORMAT_RGBX_8888:
389 format = kFormatRGBX8888;
390 break;
391 case HAL_PIXEL_FORMAT_BGRX_8888:
392 format = kFormatBGRX8888;
393 break;
394 case HAL_PIXEL_FORMAT_RGB_888:
395 format = kFormatRGB888;
396 break;
397 case HAL_PIXEL_FORMAT_RGB_565:
398 format = kFormatRGB565;
399 break;
400 case HAL_PIXEL_FORMAT_BGR_565:
401 format = kFormatBGR565;
402 break;
403 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
404 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
405 format = kFormatYCbCr420SemiPlanarVenus;
406 break;
407 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
408 format = kFormatYCrCb420SemiPlanarVenus;
409 break;
410 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
411 format = kFormatYCbCr420SPVenusUbwc;
412 break;
413 case HAL_PIXEL_FORMAT_YV12:
414 format = kFormatYCrCb420PlanarStride16;
415 break;
416 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
417 format = kFormatYCrCb420SemiPlanar;
418 break;
419 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
420 format = kFormatYCbCr420SemiPlanar;
421 break;
422 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
423 format = kFormatYCbCr422H2V1SemiPlanar;
424 break;
425 case HAL_PIXEL_FORMAT_YCbCr_422_I:
426 format = kFormatYCbCr422H2V1Packed;
427 break;
428 case HAL_PIXEL_FORMAT_RGBA_1010102:
429 format = kFormatRGBA1010102;
430 break;
431 case HAL_PIXEL_FORMAT_ARGB_2101010:
432 format = kFormatARGB2101010;
433 break;
434 case HAL_PIXEL_FORMAT_RGBX_1010102:
435 format = kFormatRGBX1010102;
436 break;
437 case HAL_PIXEL_FORMAT_XRGB_2101010:
438 format = kFormatXRGB2101010;
439 break;
440 case HAL_PIXEL_FORMAT_BGRA_1010102:
441 format = kFormatBGRA1010102;
442 break;
443 case HAL_PIXEL_FORMAT_ABGR_2101010:
444 format = kFormatABGR2101010;
445 break;
446 case HAL_PIXEL_FORMAT_BGRX_1010102:
447 format = kFormatBGRX1010102;
448 break;
449 case HAL_PIXEL_FORMAT_XBGR_2101010:
450 format = kFormatXBGR2101010;
451 break;
452 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
453 format = kFormatYCbCr420P010;
454 break;
455 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
456 format = kFormatYCbCr420TP10Ubwc;
457 break;
458 default:
459 DLOGW("Unsupported format type = %d", source);
460 return kFormatInvalid;
461 }
462
463 return format;
464 }
465
GetS3DFormat(uint32_t s3d_format)466 LayerBufferS3DFormat HWCLayer::GetS3DFormat(uint32_t s3d_format) {
467 LayerBufferS3DFormat sdm_s3d_format = kS3dFormatNone;
468 switch (s3d_format) {
469 case HAL_NO_3D:
470 sdm_s3d_format = kS3dFormatNone;
471 break;
472 case HAL_3D_SIDE_BY_SIDE_L_R:
473 sdm_s3d_format = kS3dFormatLeftRight;
474 break;
475 case HAL_3D_SIDE_BY_SIDE_R_L:
476 sdm_s3d_format = kS3dFormatRightLeft;
477 break;
478 case HAL_3D_TOP_BOTTOM:
479 sdm_s3d_format = kS3dFormatTopBottom;
480 break;
481 default:
482 DLOGW("Invalid S3D format %d", s3d_format);
483 }
484 return sdm_s3d_format;
485 }
486
SetMetaData(const private_handle_t * pvt_handle,Layer * layer)487 DisplayError HWCLayer::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
488 LayerBuffer *layer_buffer = layer->input_buffer;
489 private_handle_t *handle = const_cast<private_handle_t *>(pvt_handle);
490
491 BufferDim_t buffer_dim = {};
492 buffer_dim.sliceWidth = pvt_handle->width;
493 buffer_dim.sliceHeight = pvt_handle->height;
494 if (getMetaData(handle, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
495 #ifdef USE_GRALLOC1
496 buffer_allocator_->GetCustomWidthAndHeight(pvt_handle, &buffer_dim.sliceWidth,
497 &buffer_dim.sliceHeight);
498 #else
499 AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(handle, &buffer_dim.sliceWidth,
500 &buffer_dim.sliceHeight);
501 #endif
502 layer_buffer->width = UINT32(buffer_dim.sliceWidth);
503 layer_buffer->height = UINT32(buffer_dim.sliceHeight);
504 }
505
506 ColorSpace_t csc = ITU_R_601;
507 if (getMetaData(const_cast<private_handle_t *>(pvt_handle), GET_COLOR_SPACE, &csc) == 0) {
508 if (SetCSC(csc, &layer_buffer->csc) != kErrorNone) {
509 return kErrorNotSupported;
510 }
511 }
512
513 IGC_t igc = {};
514 LayerIGC layer_igc = layer_buffer->igc;
515 if (getMetaData(handle, GET_IGC, &igc) == 0) {
516 if (SetIGC(igc, &layer_igc) != kErrorNone) {
517 return kErrorNotSupported;
518 }
519 }
520
521 uint32_t fps = 0;
522 uint32_t frame_rate = layer->frame_rate;
523 if (getMetaData(handle, GET_REFRESH_RATE, &fps) == 0) {
524 frame_rate = RoundToStandardFPS(fps);
525 }
526
527 int32_t interlaced = 0;
528 bool interlace = layer_buffer->flags.interlace;
529 if (getMetaData(handle, GET_PP_PARAM_INTERLACED, &interlaced) == 0) {
530 interlace = interlaced ? true : false;
531 }
532
533 uint32_t linear_format = 0;
534 if (getMetaData(handle, GET_LINEAR_FORMAT, &linear_format) == 0) {
535 layer_buffer->format = GetSDMFormat(INT32(linear_format), 0);
536 }
537
538 uint32_t s3d = 0;
539 LayerBufferS3DFormat s3d_format = layer_buffer->s3d_format;
540 if (getMetaData(handle, GET_S3D_FORMAT, &s3d) == 0) {
541 s3d_format = GetS3DFormat(s3d);
542 }
543
544 if ((layer_igc != layer_buffer->igc) || (interlace != layer_buffer->flags.interlace) ||
545 (frame_rate != layer->frame_rate) || (s3d_format != layer_buffer->s3d_format)) {
546 // Layer buffer metadata has changed.
547 needs_validate_ = true;
548 layer_buffer->igc = layer_igc;
549 layer->frame_rate = frame_rate;
550 layer_buffer->s3d_format = s3d_format;
551 layer_buffer->flags.interlace = interlace;
552 }
553
554 return kErrorNone;
555 }
556
SetCSC(ColorSpace_t source,LayerCSC * target)557 DisplayError HWCLayer::SetCSC(ColorSpace_t source, LayerCSC *target) {
558 switch (source) {
559 case ITU_R_601:
560 *target = kCSCLimitedRange601;
561 break;
562 case ITU_R_601_FR:
563 *target = kCSCFullRange601;
564 break;
565 case ITU_R_709:
566 *target = kCSCLimitedRange709;
567 break;
568 default:
569 DLOGE("Unsupported CSC: %d", source);
570 return kErrorNotSupported;
571 }
572
573 return kErrorNone;
574 }
575
SetIGC(IGC_t source,LayerIGC * target)576 DisplayError HWCLayer::SetIGC(IGC_t source, LayerIGC *target) {
577 switch (source) {
578 case IGC_NotSpecified:
579 *target = kIGCNotSpecified;
580 break;
581 case IGC_sRGB:
582 *target = kIGCsRGB;
583 break;
584 default:
585 DLOGE("Unsupported IGC: %d", source);
586 return kErrorNotSupported;
587 }
588
589 return kErrorNone;
590 }
591
RoundToStandardFPS(float fps)592 uint32_t HWCLayer::RoundToStandardFPS(float fps) {
593 static const uint32_t standard_fps[4] = {24, 30, 48, 60};
594 uint32_t frame_rate = (uint32_t)(fps);
595
596 int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
597 for (int i = 0; i < count; i++) {
598 if ((standard_fps[i] - frame_rate) < 2) {
599 // Most likely used for video, the fps can fluctuate
600 // Ex: b/w 29 and 30 for 30 fps clip
601 return standard_fps[i];
602 }
603 }
604
605 return frame_rate;
606 }
607
SetComposition(const LayerComposition & sdm_composition)608 void HWCLayer::SetComposition(const LayerComposition &sdm_composition) {
609 auto hwc_composition = HWC2::Composition::Invalid;
610 switch (sdm_composition) {
611 case kCompositionGPU:
612 hwc_composition = HWC2::Composition::Client;
613 break;
614 case kCompositionHWCursor:
615 hwc_composition = HWC2::Composition::Cursor;
616 break;
617 default:
618 hwc_composition = HWC2::Composition::Device;
619 break;
620 }
621 // Update solid fill composition
622 if (sdm_composition == kCompositionSDE && layer_->flags.solid_fill != 0) {
623 hwc_composition = HWC2::Composition::SolidColor;
624 }
625 device_selected_ = hwc_composition;
626
627 return;
628 }
PushReleaseFence(int32_t fence)629 void HWCLayer::PushReleaseFence(int32_t fence) {
630 release_fences_.push(fence);
631 }
PopReleaseFence(void)632 int32_t HWCLayer::PopReleaseFence(void) {
633 if (release_fences_.empty())
634 return -1;
635 auto fence = release_fences_.front();
636 release_fences_.pop();
637 return fence;
638 }
639
SetDirtyRegions(hwc_region_t surface_damage)640 void HWCLayer::SetDirtyRegions(hwc_region_t surface_damage) {
641 layer_->dirty_regions.clear();
642 for (uint32_t i = 0; i < surface_damage.numRects; i++) {
643 LayerRect rect;
644 SetRect(surface_damage.rects[i], &rect);
645 layer_->dirty_regions.push_back(rect);
646 }
647 }
648
649 } // namespace sdm
650