1 /*
2 * Copyright (c) 2014-2016, 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 "hwc_layers.h"
21 #include <gr.h>
22 #include <utils/debug.h>
23 #include <cmath>
24
25 #define __CLASS__ "HWCLayer"
26
27 namespace sdm {
28
29 std::atomic<hwc2_layer_t> HWCLayer::next_id_(1);
30
31 // Layer operations
HWCLayer(hwc2_display_t display_id)32 HWCLayer::HWCLayer(hwc2_display_t display_id) : id_(next_id_++), display_id_(display_id) {
33 layer_ = new Layer();
34 layer_->input_buffer = new LayerBuffer();
35 // Fences are deferred, so the first time this layer is presented, return -1
36 // TODO(user): Verify that fences are properly obtained on suspend/resume
37 release_fences_.push(-1);
38 }
39
~HWCLayer()40 HWCLayer::~HWCLayer() {
41 // Close any fences left for this layer
42 while (!release_fences_.empty()) {
43 close(release_fences_.front());
44 release_fences_.pop();
45 }
46 close(ion_fd_);
47 if (layer_) {
48 if (layer_->input_buffer) {
49 delete (layer_->input_buffer);
50 }
51 delete layer_;
52 }
53 }
54
SetLayerBuffer(buffer_handle_t buffer,int32_t acquire_fence)55 HWC2::Error HWCLayer::SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence) {
56 if (!buffer) {
57 DLOGE("Invalid buffer handle: %p on layer: %d", buffer, id_);
58 return HWC2::Error::BadParameter;
59 }
60
61 if (acquire_fence == 0) {
62 DLOGE("acquire_fence is zero");
63 return HWC2::Error::BadParameter;
64 }
65
66 const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
67
68 // Validate and dup ion fd from surfaceflinger
69 // This works around bug 30281222
70 if (handle->fd < 0) {
71 return HWC2::Error::BadParameter;
72 } else {
73 close(ion_fd_);
74 ion_fd_ = dup(handle->fd);
75 }
76
77 LayerBuffer *layer_buffer = layer_->input_buffer;
78 int aligned_width, aligned_height;
79 int unaligned_width, unaligned_height;
80
81 AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(handle, aligned_width, aligned_height);
82 AdrenoMemInfo::getInstance().getUnalignedWidthAndHeight(handle, unaligned_width,
83 unaligned_height);
84
85 layer_buffer->width = UINT32(aligned_width);
86 layer_buffer->height = UINT32(aligned_height);
87 layer_buffer->unaligned_width = UINT32(unaligned_width);
88 layer_buffer->unaligned_height = UINT32(unaligned_height);
89
90 layer_buffer->format = GetSDMFormat(handle->format, handle->flags);
91 if (SetMetaData(handle, layer_) != kErrorNone) {
92 return HWC2::Error::BadLayer;
93 }
94
95 if (handle->bufferType == BUFFER_TYPE_VIDEO) {
96 layer_buffer->flags.video = true;
97 }
98 // TZ Protected Buffer - L1
99 if (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) {
100 layer_buffer->flags.secure = true;
101 if (handle->flags & private_handle_t::PRIV_FLAGS_CAMERA_WRITE) {
102 layer_buffer->flags.secure_camera = true;
103 }
104 }
105 if (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY) {
106 layer_buffer->flags.secure_display = true;
107 }
108
109 layer_buffer->planes[0].fd = ion_fd_;
110 layer_buffer->planes[0].offset = handle->offset;
111 layer_buffer->planes[0].stride = UINT32(handle->width);
112 layer_buffer->acquire_fence_fd = acquire_fence;
113 layer_buffer->size = handle->size;
114 layer_buffer->buffer_id = reinterpret_cast<uint64_t>(handle);
115
116 return HWC2::Error::None;
117 }
118
SetLayerSurfaceDamage(hwc_region_t damage)119 HWC2::Error HWCLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
120 layer_->dirty_regions.clear();
121 for (uint32_t i = 0; i < damage.numRects; i++) {
122 LayerRect rect;
123 SetRect(damage.rects[i], &rect);
124 layer_->dirty_regions.push_back(rect);
125 }
126 return HWC2::Error::None;
127 }
128
SetLayerBlendMode(HWC2::BlendMode mode)129 HWC2::Error HWCLayer::SetLayerBlendMode(HWC2::BlendMode mode) {
130 LayerBlending blending = kBlendingPremultiplied;
131 switch (mode) {
132 case HWC2::BlendMode::Coverage:
133 blending = kBlendingCoverage;
134 break;
135 case HWC2::BlendMode::Premultiplied:
136 blending = kBlendingPremultiplied;
137 break;
138 case HWC2::BlendMode::None:
139 blending = kBlendingOpaque;
140 break;
141 default:
142 return HWC2::Error::BadParameter;
143 }
144
145 if (layer_->blending != blending) {
146 geometry_changes_ |= kBlendMode;
147 layer_->blending = blending;
148 }
149 return HWC2::Error::None;
150 }
151
SetLayerColor(hwc_color_t color)152 HWC2::Error HWCLayer::SetLayerColor(hwc_color_t color) {
153 layer_->solid_fill_color = GetUint32Color(color);
154 layer_->input_buffer->format = kFormatARGB8888;
155 DLOGV_IF(kTagCompManager, "[%" PRIu64 "][%" PRIu64 "] Layer color set to %x", display_id_, id_,
156 layer_->solid_fill_color);
157 return HWC2::Error::None;
158 }
159
SetLayerCompositionType(HWC2::Composition type)160 HWC2::Error HWCLayer::SetLayerCompositionType(HWC2::Composition type) {
161 client_requested_ = type;
162 switch (type) {
163 case HWC2::Composition::Client:
164 break;
165 case HWC2::Composition::Device:
166 // We try and default to this in SDM
167 break;
168 case HWC2::Composition::SolidColor:
169 break;
170 case HWC2::Composition::Cursor:
171 break;
172 case HWC2::Composition::Invalid:
173 return HWC2::Error::BadParameter;
174 default:
175 return HWC2::Error::Unsupported;
176 }
177
178 return HWC2::Error::None;
179 }
180
SetLayerDataspace(int32_t dataspace)181 HWC2::Error HWCLayer::SetLayerDataspace(int32_t dataspace) {
182 // TODO(user): Implement later
183 geometry_changes_ |= kDataspace;
184 return HWC2::Error::None;
185 }
186
SetLayerDisplayFrame(hwc_rect_t frame)187 HWC2::Error HWCLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
188 LayerRect dst_rect = {};
189 SetRect(frame, &dst_rect);
190 if (layer_->dst_rect != dst_rect) {
191 geometry_changes_ |= kDisplayFrame;
192 layer_->dst_rect = dst_rect;
193 }
194 return HWC2::Error::None;
195 }
196
SetLayerPlaneAlpha(float alpha)197 HWC2::Error HWCLayer::SetLayerPlaneAlpha(float alpha) {
198 // Conversion of float alpha in range 0.0 to 1.0 similar to the HWC Adapter
199 uint8_t plane_alpha = static_cast<uint8_t>(std::round(255.0f * alpha));
200 if (layer_->plane_alpha != plane_alpha) {
201 geometry_changes_ |= kPlaneAlpha;
202 layer_->plane_alpha = plane_alpha;
203 }
204
205 return HWC2::Error::None;
206 }
207
SetLayerSourceCrop(hwc_frect_t crop)208 HWC2::Error HWCLayer::SetLayerSourceCrop(hwc_frect_t crop) {
209 LayerRect src_rect = {};
210 SetRect(crop, &src_rect);
211 if (layer_->src_rect != src_rect) {
212 geometry_changes_ |= kSourceCrop;
213 layer_->src_rect = src_rect;
214 }
215
216 return HWC2::Error::None;
217 }
218
SetLayerTransform(HWC2::Transform transform)219 HWC2::Error HWCLayer::SetLayerTransform(HWC2::Transform transform) {
220 LayerTransform layer_transform = {};
221 switch (transform) {
222 case HWC2::Transform::FlipH:
223 layer_transform.flip_horizontal = true;
224 break;
225 case HWC2::Transform::FlipV:
226 layer_transform.flip_vertical = true;
227 break;
228 case HWC2::Transform::Rotate90:
229 layer_transform.rotation = 90.0f;
230 break;
231 case HWC2::Transform::Rotate180:
232 layer_transform.flip_horizontal = true;
233 layer_transform.flip_vertical = true;
234 break;
235 case HWC2::Transform::Rotate270:
236 layer_transform.rotation = 90.0f;
237 layer_transform.flip_horizontal = true;
238 layer_transform.flip_vertical = true;
239 break;
240 case HWC2::Transform::FlipHRotate90:
241 layer_transform.rotation = 90.0f;
242 layer_transform.flip_horizontal = true;
243 break;
244 case HWC2::Transform::FlipVRotate90:
245 layer_transform.rotation = 90.0f;
246 layer_transform.flip_vertical = true;
247 break;
248 case HWC2::Transform::None:
249 // do nothing
250 break;
251 }
252
253 if (layer_->transform != layer_transform) {
254 geometry_changes_ |= kTransform;
255 layer_->transform = layer_transform;
256 }
257 return HWC2::Error::None;
258 }
259
SetLayerVisibleRegion(hwc_region_t visible)260 HWC2::Error HWCLayer::SetLayerVisibleRegion(hwc_region_t visible) {
261 layer_->visible_regions.clear();
262 for (uint32_t i = 0; i < visible.numRects; i++) {
263 LayerRect rect;
264 SetRect(visible.rects[i], &rect);
265 layer_->visible_regions.push_back(rect);
266 }
267
268 return HWC2::Error::None;
269 }
270
SetLayerZOrder(uint32_t z)271 HWC2::Error HWCLayer::SetLayerZOrder(uint32_t z) {
272 if (z_ != z) {
273 geometry_changes_ |= kZOrder;
274 z_ = z;
275 }
276 return HWC2::Error::None;
277 }
278
SetRect(const hwc_rect_t & source,LayerRect * target)279 void HWCLayer::SetRect(const hwc_rect_t &source, LayerRect *target) {
280 target->left = FLOAT(source.left);
281 target->top = FLOAT(source.top);
282 target->right = FLOAT(source.right);
283 target->bottom = FLOAT(source.bottom);
284 }
285
SetRect(const hwc_frect_t & source,LayerRect * target)286 void HWCLayer::SetRect(const hwc_frect_t &source, LayerRect *target) {
287 // Recommended way of rounding as in hwcomposer2.h - SetLayerSourceCrop
288 target->left = std::ceil(source.left);
289 target->top = std::ceil(source.top);
290 target->right = std::floor(source.right);
291 target->bottom = std::floor(source.bottom);
292 }
293
GetUint32Color(const hwc_color_t & source)294 uint32_t HWCLayer::GetUint32Color(const hwc_color_t &source) {
295 // Returns 32 bit ARGB
296 uint32_t a = UINT32(source.a) << 24;
297 uint32_t r = UINT32(source.r) << 16;
298 uint32_t g = UINT32(source.g) << 8;
299 uint32_t b = UINT32(source.b);
300 uint32_t color = a | r | g | b;
301 return color;
302 }
303
GetSDMFormat(const int32_t & source,const int flags)304 LayerBufferFormat HWCLayer::GetSDMFormat(const int32_t &source, const int flags) {
305 LayerBufferFormat format = kFormatInvalid;
306 if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
307 switch (source) {
308 case HAL_PIXEL_FORMAT_RGBA_8888:
309 format = kFormatRGBA8888Ubwc;
310 break;
311 case HAL_PIXEL_FORMAT_RGBX_8888:
312 format = kFormatRGBX8888Ubwc;
313 break;
314 case HAL_PIXEL_FORMAT_BGR_565:
315 format = kFormatBGR565Ubwc;
316 break;
317 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
318 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
319 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
320 format = kFormatYCbCr420SPVenusUbwc;
321 break;
322 default:
323 DLOGE("Unsupported format type for UBWC %d", source);
324 return kFormatInvalid;
325 }
326 return format;
327 }
328
329 switch (source) {
330 case HAL_PIXEL_FORMAT_RGBA_8888:
331 format = kFormatRGBA8888;
332 break;
333 case HAL_PIXEL_FORMAT_RGBA_5551:
334 format = kFormatRGBA5551;
335 break;
336 case HAL_PIXEL_FORMAT_RGBA_4444:
337 format = kFormatRGBA4444;
338 break;
339 case HAL_PIXEL_FORMAT_BGRA_8888:
340 format = kFormatBGRA8888;
341 break;
342 case HAL_PIXEL_FORMAT_RGBX_8888:
343 format = kFormatRGBX8888;
344 break;
345 case HAL_PIXEL_FORMAT_BGRX_8888:
346 format = kFormatBGRX8888;
347 break;
348 case HAL_PIXEL_FORMAT_RGB_888:
349 format = kFormatRGB888;
350 break;
351 case HAL_PIXEL_FORMAT_RGB_565:
352 format = kFormatRGB565;
353 break;
354 case HAL_PIXEL_FORMAT_BGR_565:
355 format = kFormatBGR565;
356 break;
357 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
358 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
359 format = kFormatYCbCr420SemiPlanarVenus;
360 break;
361 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
362 format = kFormatYCrCb420SemiPlanarVenus;
363 break;
364 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
365 format = kFormatYCbCr420SPVenusUbwc;
366 break;
367 case HAL_PIXEL_FORMAT_YV12:
368 format = kFormatYCrCb420PlanarStride16;
369 break;
370 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
371 format = kFormatYCrCb420SemiPlanar;
372 break;
373 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
374 format = kFormatYCbCr420SemiPlanar;
375 break;
376 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
377 format = kFormatYCbCr422H2V1SemiPlanar;
378 break;
379 case HAL_PIXEL_FORMAT_YCbCr_422_I:
380 format = kFormatYCbCr422H2V1Packed;
381 break;
382 case HAL_PIXEL_FORMAT_RGBA_1010102:
383 format = kFormatRGBA1010102;
384 break;
385 case HAL_PIXEL_FORMAT_ARGB_2101010:
386 format = kFormatARGB2101010;
387 break;
388 case HAL_PIXEL_FORMAT_RGBX_1010102:
389 format = kFormatRGBX1010102;
390 break;
391 case HAL_PIXEL_FORMAT_XRGB_2101010:
392 format = kFormatXRGB2101010;
393 break;
394 case HAL_PIXEL_FORMAT_BGRA_1010102:
395 format = kFormatBGRA1010102;
396 break;
397 case HAL_PIXEL_FORMAT_ABGR_2101010:
398 format = kFormatABGR2101010;
399 break;
400 case HAL_PIXEL_FORMAT_BGRX_1010102:
401 format = kFormatBGRX1010102;
402 break;
403 case HAL_PIXEL_FORMAT_XBGR_2101010:
404 format = kFormatXBGR2101010;
405 break;
406 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
407 format = kFormatYCbCr420P010;
408 break;
409 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
410 format = kFormatYCbCr420TP10Ubwc;
411 break;
412 default:
413 DLOGW("Unsupported format type = %d", source);
414 return kFormatInvalid;
415 }
416
417 return format;
418 }
419
GetS3DFormat(uint32_t s3d_format)420 LayerBufferS3DFormat HWCLayer::GetS3DFormat(uint32_t s3d_format) {
421 LayerBufferS3DFormat sdm_s3d_format = kS3dFormatNone;
422 switch (s3d_format) {
423 case HAL_NO_3D:
424 sdm_s3d_format = kS3dFormatNone;
425 break;
426 case HAL_3D_SIDE_BY_SIDE_L_R:
427 sdm_s3d_format = kS3dFormatLeftRight;
428 break;
429 case HAL_3D_SIDE_BY_SIDE_R_L:
430 sdm_s3d_format = kS3dFormatRightLeft;
431 break;
432 case HAL_3D_TOP_BOTTOM:
433 sdm_s3d_format = kS3dFormatTopBottom;
434 break;
435 default:
436 DLOGW("Invalid S3D format %d", s3d_format);
437 }
438 return sdm_s3d_format;
439 }
440
SetMetaData(const private_handle_t * pvt_handle,Layer * layer)441 DisplayError HWCLayer::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
442 const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata);
443 LayerBuffer *layer_buffer = layer->input_buffer;
444
445 if (!meta_data) {
446 return kErrorNone;
447 }
448
449 if (meta_data->operation & UPDATE_COLOR_SPACE) {
450 if (SetCSC(meta_data->colorSpace, &layer_buffer->csc) != kErrorNone) {
451 return kErrorNotSupported;
452 }
453 }
454
455 if (meta_data->operation & SET_IGC) {
456 if (SetIGC(meta_data->igc, &layer_buffer->igc) != kErrorNone) {
457 return kErrorNotSupported;
458 }
459 }
460
461 if (meta_data->operation & UPDATE_REFRESH_RATE) {
462 layer->frame_rate = RoundToStandardFPS(meta_data->refreshrate);
463 }
464
465 if ((meta_data->operation & PP_PARAM_INTERLACED) && meta_data->interlaced) {
466 layer_buffer->flags.interlace = true;
467 }
468
469 if (meta_data->operation & LINEAR_FORMAT) {
470 layer_buffer->format = GetSDMFormat(INT32(meta_data->linearFormat), 0);
471 }
472
473 if (meta_data->operation & S3D_FORMAT) {
474 layer_buffer->s3d_format = GetS3DFormat(meta_data->s3dFormat);
475 }
476
477 return kErrorNone;
478 }
479
SetCSC(ColorSpace_t source,LayerCSC * target)480 DisplayError HWCLayer::SetCSC(ColorSpace_t source, LayerCSC *target) {
481 switch (source) {
482 case ITU_R_601:
483 *target = kCSCLimitedRange601;
484 break;
485 case ITU_R_601_FR:
486 *target = kCSCFullRange601;
487 break;
488 case ITU_R_709:
489 *target = kCSCLimitedRange709;
490 break;
491 default:
492 DLOGE("Unsupported CSC: %d", source);
493 return kErrorNotSupported;
494 }
495
496 return kErrorNone;
497 }
498
SetIGC(IGC_t source,LayerIGC * target)499 DisplayError HWCLayer::SetIGC(IGC_t source, LayerIGC *target) {
500 switch (source) {
501 case IGC_NotSpecified:
502 *target = kIGCNotSpecified;
503 break;
504 case IGC_sRGB:
505 *target = kIGCsRGB;
506 break;
507 default:
508 DLOGE("Unsupported IGC: %d", source);
509 return kErrorNotSupported;
510 }
511
512 return kErrorNone;
513 }
514
RoundToStandardFPS(float fps)515 uint32_t HWCLayer::RoundToStandardFPS(float fps) {
516 static const uint32_t standard_fps[4] = {24, 30, 48, 60};
517 uint32_t frame_rate = (uint32_t)(fps);
518
519 int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
520 for (int i = 0; i < count; i++) {
521 if ((standard_fps[i] - frame_rate) < 2) {
522 // Most likely used for video, the fps can fluctuate
523 // Ex: b/w 29 and 30 for 30 fps clip
524 return standard_fps[i];
525 }
526 }
527
528 return frame_rate;
529 }
530
SetComposition(const LayerComposition & sdm_composition)531 void HWCLayer::SetComposition(const LayerComposition &sdm_composition) {
532 auto hwc_composition = HWC2::Composition::Invalid;
533 switch (sdm_composition) {
534 case kCompositionGPU:
535 hwc_composition = HWC2::Composition::Client;
536 break;
537 case kCompositionHWCursor:
538 hwc_composition = HWC2::Composition::Cursor;
539 break;
540 default:
541 hwc_composition = HWC2::Composition::Device;
542 break;
543 }
544 // Update solid fill composition
545 if (sdm_composition == kCompositionSDE && layer_->flags.solid_fill != 0) {
546 hwc_composition = HWC2::Composition::SolidColor;
547 }
548 device_selected_ = hwc_composition;
549
550 return;
551 }
PushReleaseFence(int32_t fence)552 void HWCLayer::PushReleaseFence(int32_t fence) {
553 release_fences_.push(fence);
554 }
PopReleaseFence(void)555 int32_t HWCLayer::PopReleaseFence(void) {
556 if (release_fences_.empty())
557 return -1;
558 auto fence = release_fences_.front();
559 release_fences_.pop();
560 return fence;
561 }
562
563 } // namespace sdm
564