1/* 2 * Copyright (c) 2014-2017, 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 32namespace sdm { 33 34std::atomic<hwc2_layer_t> HWCLayer::next_id_(1); 35 36DisplayError SetCSC(const private_handle_t *pvt_handle, ColorMetaData *color_metadata) { 37 if (getMetaData(const_cast<private_handle_t *>(pvt_handle), GET_COLOR_METADATA, 38 color_metadata) != 0) { 39 ColorSpace_t csc = ITU_R_601; 40 if (getMetaData(const_cast<private_handle_t *>(pvt_handle), GET_COLOR_SPACE, 41 &csc) == 0) { 42 if (csc == ITU_R_601_FR || csc == ITU_R_2020_FR) { 43 color_metadata->range = Range_Full; 44 } 45 46 switch (csc) { 47 case ITU_R_601: 48 case ITU_R_601_FR: 49 // video and display driver uses 601_525 50 color_metadata->colorPrimaries = ColorPrimaries_BT601_6_525; 51 break; 52 case ITU_R_709: 53 color_metadata->colorPrimaries = ColorPrimaries_BT709_5; 54 break; 55 case ITU_R_2020: 56 case ITU_R_2020_FR: 57 color_metadata->colorPrimaries = ColorPrimaries_BT2020; 58 break; 59 default: 60 DLOGE("Unsupported CSC: %d", csc); 61 return kErrorNotSupported; 62 } 63 } else { 64 return kErrorNotSupported; 65 } 66 } 67 68 return kErrorNone; 69} 70 71// Returns true when color primary is supported 72bool GetColorPrimary(const int32_t &dataspace, ColorPrimaries *color_primary) { 73 auto standard = dataspace & HAL_DATASPACE_STANDARD_MASK; 74 bool supported_csc = true; 75 switch (standard) { 76 case HAL_DATASPACE_STANDARD_BT709: 77 *color_primary = ColorPrimaries_BT709_5; 78 break; 79 case HAL_DATASPACE_STANDARD_BT601_525: 80 case HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED: 81 *color_primary = ColorPrimaries_BT601_6_525; 82 break; 83 case HAL_DATASPACE_STANDARD_BT601_625: 84 case HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED: 85 *color_primary = ColorPrimaries_BT601_6_625; 86 break; 87 case HAL_DATASPACE_STANDARD_DCI_P3: 88 *color_primary = ColorPrimaries_DCIP3; 89 break; 90 case HAL_DATASPACE_STANDARD_BT2020: 91 *color_primary = ColorPrimaries_BT2020; 92 break; 93 default: 94 DLOGV_IF(kTagStrategy, "Unsupported Standard Request = %d", standard); 95 supported_csc = false; 96 } 97 return supported_csc; 98} 99 100bool GetTransfer(const int32_t &dataspace, GammaTransfer *gamma_transfer) { 101 auto transfer = dataspace & HAL_DATASPACE_TRANSFER_MASK; 102 bool supported_transfer = true; 103 switch (transfer) { 104 case HAL_DATASPACE_TRANSFER_SRGB: 105 *gamma_transfer = Transfer_sRGB; 106 break; 107 case HAL_DATASPACE_TRANSFER_SMPTE_170M: 108 *gamma_transfer = Transfer_SMPTE_170M; 109 break; 110 case HAL_DATASPACE_TRANSFER_ST2084: 111 *gamma_transfer = Transfer_SMPTE_ST2084; 112 break; 113 case HAL_DATASPACE_TRANSFER_HLG: 114 *gamma_transfer = Transfer_HLG; 115 break; 116 case HAL_DATASPACE_TRANSFER_LINEAR: 117 *gamma_transfer = Transfer_Linear; 118 break; 119 case HAL_DATASPACE_TRANSFER_GAMMA2_2: 120 *gamma_transfer = Transfer_Gamma2_2; 121 break; 122 case HAL_DATASPACE_TRANSFER_GAMMA2_8: 123 *gamma_transfer = Transfer_Gamma2_8; 124 break; 125 default: 126 DLOGE("Unsupported Transfer Request = %d", transfer); 127 supported_transfer = false; 128 } 129 return supported_transfer; 130} 131 132void GetRange(const int32_t &dataspace, ColorRange *color_range) { 133 auto range = dataspace & HAL_DATASPACE_RANGE_MASK; 134 switch (range) { 135 case HAL_DATASPACE_RANGE_FULL: 136 *color_range = Range_Full; 137 break; 138 case HAL_DATASPACE_RANGE_LIMITED: 139 *color_range = Range_Limited; 140 break; 141 default: 142 DLOGV_IF(kTagStrategy, "Unsupported Range Request = %d", range); 143 break; 144 } 145} 146 147bool IsBT2020(const ColorPrimaries &color_primary) { 148 switch (color_primary) { 149 case ColorPrimaries_BT2020: 150 return true; 151 break; 152 default: 153 return false; 154 } 155} 156 157// Retrieve ColorMetaData from android_data_space_t (STANDARD|TRANSFER|RANGE) 158bool GetSDMColorSpace(const int32_t &dataspace, ColorMetaData *color_metadata) { 159 bool valid = false; 160 valid = GetColorPrimary(dataspace, &(color_metadata->colorPrimaries)); 161 if (!valid) { 162 return valid; 163 } 164 valid = GetTransfer(dataspace, &(color_metadata->transfer)); 165 if (!valid) { 166 return valid; 167 } 168 GetRange(dataspace, &(color_metadata->range)); 169 170 return true; 171} 172 173// Layer operations 174HWCLayer::HWCLayer(hwc2_display_t display_id, HWCBufferAllocator *buf_allocator) 175 : id_(next_id_++), display_id_(display_id), buffer_allocator_(buf_allocator) { 176 layer_ = new Layer(); 177 // Fences are deferred, so the first time this layer is presented, return -1 178 // TODO(user): Verify that fences are properly obtained on suspend/resume 179 release_fences_.push(-1); 180} 181 182HWCLayer::~HWCLayer() { 183 // Close any fences left for this layer 184 while (!release_fences_.empty()) { 185 close(release_fences_.front()); 186 release_fences_.pop(); 187 } 188 close(ion_fd_); 189 if (layer_) { 190 delete layer_; 191 } 192} 193 194HWC2::Error HWCLayer::SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence) { 195 if (!buffer) { 196 if (client_requested_ == HWC2::Composition::Device || 197 client_requested_ == HWC2::Composition::Cursor) { 198 DLOGE("Invalid buffer handle: %p on layer: %d", buffer, id_); 199 return HWC2::Error::BadParameter; 200 } else { 201 return HWC2::Error::None; 202 } 203 } 204 205 if (acquire_fence == 0) { 206 DLOGE("acquire_fence is zero"); 207 return HWC2::Error::BadParameter; 208 } 209 210 const private_handle_t *handle = static_cast<const private_handle_t *>(buffer); 211 212 // Validate and dup ion fd from surfaceflinger 213 // This works around bug 30281222 214 if (handle->fd < 0) { 215 return HWC2::Error::BadParameter; 216 } else { 217 close(ion_fd_); 218 ion_fd_ = dup(handle->fd); 219 } 220 221 LayerBuffer *layer_buffer = &layer_->input_buffer; 222 int aligned_width, aligned_height; 223#ifdef USE_GRALLOC1 224 buffer_allocator_->GetCustomWidthAndHeight(handle, &aligned_width, &aligned_height); 225#else 226 AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(handle, aligned_width, aligned_height); 227#endif 228 229 LayerBufferFormat format = GetSDMFormat(handle->format, handle->flags); 230 if ((format != layer_buffer->format) || (UINT32(aligned_width) != layer_buffer->width) || 231 (UINT32(aligned_height) != layer_buffer->height)) { 232 // Layer buffer geometry has changed. 233 geometry_changes_ |= kBufferGeometry; 234 } 235 236 layer_buffer->format = format; 237 layer_buffer->width = UINT32(aligned_width); 238 layer_buffer->height = UINT32(aligned_height); 239 layer_buffer->unaligned_width = UINT32(handle->unaligned_width); 240 layer_buffer->unaligned_height = UINT32(handle->unaligned_height); 241 242 if (SetMetaData(const_cast<private_handle_t *>(handle), layer_) != kErrorNone) { 243 return HWC2::Error::BadLayer; 244 } 245 246 layer_buffer->flags.video = (handle->buffer_type == BUFFER_TYPE_VIDEO) ? true : false; 247 248 // TZ Protected Buffer - L1 249 bool secure = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER); 250 bool secure_camera = secure && (handle->flags & private_handle_t::PRIV_FLAGS_CAMERA_WRITE); 251 bool secure_display = (handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY); 252 if (secure != layer_buffer->flags.secure || secure_camera != layer_buffer->flags.secure_camera || 253 secure_display != layer_buffer->flags.secure_display) { 254 // Secure attribute of layer buffer has changed. 255 needs_validate_ = true; 256 } 257 258 layer_buffer->flags.secure = secure; 259 layer_buffer->flags.secure_camera = secure_camera; 260 layer_buffer->flags.secure_display = secure_display; 261 262 if (layer_buffer->acquire_fence_fd >= 0) { 263 close(layer_buffer->acquire_fence_fd); 264 } 265 layer_buffer->acquire_fence_fd = acquire_fence; 266 layer_buffer->planes[0].fd = ion_fd_; 267 layer_buffer->planes[0].offset = handle->offset; 268 layer_buffer->planes[0].stride = UINT32(handle->width); 269 layer_buffer->size = handle->size; 270 layer_buffer->buffer_id = reinterpret_cast<uint64_t>(handle); 271 layer_buffer->fb_id = 0; 272 273 return HWC2::Error::None; 274} 275 276HWC2::Error HWCLayer::SetLayerSurfaceDamage(hwc_region_t damage) { 277 // Check if there is an update in SurfaceDamage rects 278 if (layer_->dirty_regions.size() != damage.numRects) { 279 needs_validate_ = true; 280 } else { 281 for (uint32_t j = 0; j < damage.numRects; j++) { 282 LayerRect damage_rect; 283 SetRect(damage.rects[j], &damage_rect); 284 if (damage_rect != layer_->dirty_regions.at(j)) { 285 needs_validate_ = true; 286 break; 287 } 288 } 289 } 290 291 layer_->dirty_regions.clear(); 292 for (uint32_t i = 0; i < damage.numRects; i++) { 293 LayerRect rect; 294 SetRect(damage.rects[i], &rect); 295 layer_->dirty_regions.push_back(rect); 296 } 297 return HWC2::Error::None; 298} 299 300HWC2::Error HWCLayer::SetLayerBlendMode(HWC2::BlendMode mode) { 301 LayerBlending blending = kBlendingPremultiplied; 302 switch (mode) { 303 case HWC2::BlendMode::Coverage: 304 blending = kBlendingCoverage; 305 break; 306 case HWC2::BlendMode::Premultiplied: 307 blending = kBlendingPremultiplied; 308 break; 309 case HWC2::BlendMode::None: 310 blending = kBlendingOpaque; 311 break; 312 default: 313 return HWC2::Error::BadParameter; 314 } 315 316 if (layer_->blending != blending) { 317 geometry_changes_ |= kBlendMode; 318 layer_->blending = blending; 319 } 320 return HWC2::Error::None; 321} 322 323HWC2::Error HWCLayer::SetLayerColor(hwc_color_t color) { 324 if (client_requested_ != HWC2::Composition::SolidColor) { 325 return HWC2::Error::None; 326 } 327 layer_->solid_fill_color = GetUint32Color(color); 328 layer_->input_buffer.format = kFormatARGB8888; 329 DLOGV_IF(kTagCompManager, "[%" PRIu64 "][%" PRIu64 "] Layer color set to %x", display_id_, id_, 330 layer_->solid_fill_color); 331 return HWC2::Error::None; 332} 333 334HWC2::Error HWCLayer::SetLayerCompositionType(HWC2::Composition type) { 335 // Validation is required when the client changes the composition type 336 if (client_requested_ != type) { 337 needs_validate_ = true; 338 } 339 client_requested_ = type; 340 switch (type) { 341 case HWC2::Composition::Client: 342 break; 343 case HWC2::Composition::Device: 344 // We try and default to this in SDM 345 break; 346 case HWC2::Composition::SolidColor: 347 break; 348 case HWC2::Composition::Cursor: 349 break; 350 case HWC2::Composition::Invalid: 351 return HWC2::Error::BadParameter; 352 default: 353 return HWC2::Error::Unsupported; 354 } 355 356 return HWC2::Error::None; 357} 358 359HWC2::Error HWCLayer::SetLayerDataspace(int32_t dataspace) { 360 // Map deprecated dataspace values to appropriate 361 // new enums 362 if (dataspace & 0xffff) { 363 switch (dataspace & 0xffff) { 364 case HAL_DATASPACE_SRGB: 365 dataspace = HAL_DATASPACE_V0_SRGB; 366 break; 367 case HAL_DATASPACE_JFIF: 368 dataspace = HAL_DATASPACE_V0_JFIF; 369 break; 370 case HAL_DATASPACE_SRGB_LINEAR: 371 dataspace = HAL_DATASPACE_V0_SRGB_LINEAR; 372 break; 373 case HAL_DATASPACE_BT601_625: 374 dataspace = HAL_DATASPACE_V0_BT601_625; 375 break; 376 case HAL_DATASPACE_BT601_525: 377 dataspace = HAL_DATASPACE_V0_BT601_525; 378 break; 379 case HAL_DATASPACE_BT709: 380 dataspace = HAL_DATASPACE_V0_BT709; 381 break; 382 default: 383 // unknown legacy dataspace 384 DLOGW_IF(kTagQDCM, "Unsupported dataspace type %d", dataspace); 385 } 386 } 387 388 // cache the dataspace, to be used later to update SDM ColorMetaData 389 if (dataspace_ != dataspace) { 390 geometry_changes_ |= kDataspace; 391 dataspace_ = dataspace; 392 } 393 return HWC2::Error::None; 394} 395 396HWC2::Error HWCLayer::SetLayerDisplayFrame(hwc_rect_t frame) { 397 LayerRect dst_rect = {}; 398 SetRect(frame, &dst_rect); 399 if (layer_->dst_rect != dst_rect) { 400 geometry_changes_ |= kDisplayFrame; 401 layer_->dst_rect = dst_rect; 402 } 403 return HWC2::Error::None; 404} 405 406HWC2::Error HWCLayer::SetLayerPlaneAlpha(float alpha) { 407 // Conversion of float alpha in range 0.0 to 1.0 similar to the HWC Adapter 408 uint8_t plane_alpha = static_cast<uint8_t>(std::round(255.0f * alpha)); 409 if (layer_->plane_alpha != plane_alpha) { 410 geometry_changes_ |= kPlaneAlpha; 411 layer_->plane_alpha = plane_alpha; 412 } 413 414 return HWC2::Error::None; 415} 416 417HWC2::Error HWCLayer::SetLayerSourceCrop(hwc_frect_t crop) { 418 LayerRect src_rect = {}; 419 SetRect(crop, &src_rect); 420 if (layer_->src_rect != src_rect) { 421 geometry_changes_ |= kSourceCrop; 422 layer_->src_rect = src_rect; 423 } 424 425 return HWC2::Error::None; 426} 427 428HWC2::Error HWCLayer::SetLayerTransform(HWC2::Transform transform) { 429 LayerTransform layer_transform = {}; 430 switch (transform) { 431 case HWC2::Transform::FlipH: 432 layer_transform.flip_horizontal = true; 433 break; 434 case HWC2::Transform::FlipV: 435 layer_transform.flip_vertical = true; 436 break; 437 case HWC2::Transform::Rotate90: 438 layer_transform.rotation = 90.0f; 439 break; 440 case HWC2::Transform::Rotate180: 441 layer_transform.flip_horizontal = true; 442 layer_transform.flip_vertical = true; 443 break; 444 case HWC2::Transform::Rotate270: 445 layer_transform.rotation = 90.0f; 446 layer_transform.flip_horizontal = true; 447 layer_transform.flip_vertical = true; 448 break; 449 case HWC2::Transform::FlipHRotate90: 450 layer_transform.rotation = 90.0f; 451 layer_transform.flip_horizontal = true; 452 break; 453 case HWC2::Transform::FlipVRotate90: 454 layer_transform.rotation = 90.0f; 455 layer_transform.flip_vertical = true; 456 break; 457 case HWC2::Transform::None: 458 // do nothing 459 break; 460 } 461 462 if (layer_->transform != layer_transform) { 463 geometry_changes_ |= kTransform; 464 layer_->transform = layer_transform; 465 } 466 return HWC2::Error::None; 467} 468 469HWC2::Error HWCLayer::SetLayerVisibleRegion(hwc_region_t visible) { 470 layer_->visible_regions.clear(); 471 for (uint32_t i = 0; i < visible.numRects; i++) { 472 LayerRect rect; 473 SetRect(visible.rects[i], &rect); 474 layer_->visible_regions.push_back(rect); 475 } 476 477 return HWC2::Error::None; 478} 479 480HWC2::Error HWCLayer::SetLayerZOrder(uint32_t z) { 481 if (z_ != z) { 482 geometry_changes_ |= kZOrder; 483 z_ = z; 484 } 485 return HWC2::Error::None; 486} 487 488void HWCLayer::SetRect(const hwc_rect_t &source, LayerRect *target) { 489 target->left = FLOAT(source.left); 490 target->top = FLOAT(source.top); 491 target->right = FLOAT(source.right); 492 target->bottom = FLOAT(source.bottom); 493} 494 495void HWCLayer::SetRect(const hwc_frect_t &source, LayerRect *target) { 496 // Recommended way of rounding as in hwcomposer2.h - SetLayerSourceCrop 497 target->left = std::ceil(source.left); 498 target->top = std::ceil(source.top); 499 target->right = std::floor(source.right); 500 target->bottom = std::floor(source.bottom); 501} 502 503uint32_t HWCLayer::GetUint32Color(const hwc_color_t &source) { 504 // Returns 32 bit ARGB 505 uint32_t a = UINT32(source.a) << 24; 506 uint32_t r = UINT32(source.r) << 16; 507 uint32_t g = UINT32(source.g) << 8; 508 uint32_t b = UINT32(source.b); 509 uint32_t color = a | r | g | b; 510 return color; 511} 512 513LayerBufferFormat HWCLayer::GetSDMFormat(const int32_t &source, const int flags) { 514 LayerBufferFormat format = kFormatInvalid; 515 if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) { 516 switch (source) { 517 case HAL_PIXEL_FORMAT_RGBA_8888: 518 format = kFormatRGBA8888Ubwc; 519 break; 520 case HAL_PIXEL_FORMAT_RGBX_8888: 521 format = kFormatRGBX8888Ubwc; 522 break; 523 case HAL_PIXEL_FORMAT_BGR_565: 524 format = kFormatBGR565Ubwc; 525 break; 526 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS: 527 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC: 528 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 529 format = kFormatYCbCr420SPVenusUbwc; 530 break; 531 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC: 532 format = kFormatYCbCr420TP10Ubwc; 533 break; 534 default: 535 DLOGE("Unsupported format type for UBWC %d", source); 536 return kFormatInvalid; 537 } 538 return format; 539 } 540 541 switch (source) { 542 case HAL_PIXEL_FORMAT_RGBA_8888: 543 format = kFormatRGBA8888; 544 break; 545 case HAL_PIXEL_FORMAT_RGBA_5551: 546 format = kFormatRGBA5551; 547 break; 548 case HAL_PIXEL_FORMAT_RGBA_4444: 549 format = kFormatRGBA4444; 550 break; 551 case HAL_PIXEL_FORMAT_BGRA_8888: 552 format = kFormatBGRA8888; 553 break; 554 case HAL_PIXEL_FORMAT_RGBX_8888: 555 format = kFormatRGBX8888; 556 break; 557 case HAL_PIXEL_FORMAT_BGRX_8888: 558 format = kFormatBGRX8888; 559 break; 560 case HAL_PIXEL_FORMAT_RGB_888: 561 format = kFormatRGB888; 562 break; 563 case HAL_PIXEL_FORMAT_RGB_565: 564 format = kFormatRGB565; 565 break; 566 case HAL_PIXEL_FORMAT_BGR_565: 567 format = kFormatBGR565; 568 break; 569 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 570 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS: 571 format = kFormatYCbCr420SemiPlanarVenus; 572 break; 573 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS: 574 format = kFormatYCrCb420SemiPlanarVenus; 575 break; 576 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC: 577 format = kFormatYCbCr420SPVenusUbwc; 578 break; 579 case HAL_PIXEL_FORMAT_YV12: 580 format = kFormatYCrCb420PlanarStride16; 581 break; 582 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 583 format = kFormatYCrCb420SemiPlanar; 584 break; 585 case HAL_PIXEL_FORMAT_YCbCr_420_SP: 586 format = kFormatYCbCr420SemiPlanar; 587 break; 588 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 589 format = kFormatYCbCr422H2V1SemiPlanar; 590 break; 591 case HAL_PIXEL_FORMAT_YCbCr_422_I: 592 format = kFormatYCbCr422H2V1Packed; 593 break; 594 case HAL_PIXEL_FORMAT_RGBA_1010102: 595 format = kFormatRGBA1010102; 596 break; 597 case HAL_PIXEL_FORMAT_ARGB_2101010: 598 format = kFormatARGB2101010; 599 break; 600 case HAL_PIXEL_FORMAT_RGBX_1010102: 601 format = kFormatRGBX1010102; 602 break; 603 case HAL_PIXEL_FORMAT_XRGB_2101010: 604 format = kFormatXRGB2101010; 605 break; 606 case HAL_PIXEL_FORMAT_BGRA_1010102: 607 format = kFormatBGRA1010102; 608 break; 609 case HAL_PIXEL_FORMAT_ABGR_2101010: 610 format = kFormatABGR2101010; 611 break; 612 case HAL_PIXEL_FORMAT_BGRX_1010102: 613 format = kFormatBGRX1010102; 614 break; 615 case HAL_PIXEL_FORMAT_XBGR_2101010: 616 format = kFormatXBGR2101010; 617 break; 618 case HAL_PIXEL_FORMAT_YCbCr_420_P010: 619 format = kFormatYCbCr420P010; 620 break; 621 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC: 622 format = kFormatYCbCr420TP10Ubwc; 623 break; 624 case HAL_PIXEL_FORMAT_RGBA_FP16: 625 format = kFormatInvalid; 626 break; 627 default: 628 DLOGW("Unsupported format type = %d", source); 629 return kFormatInvalid; 630 } 631 632 return format; 633} 634 635LayerBufferS3DFormat HWCLayer::GetS3DFormat(uint32_t s3d_format) { 636 LayerBufferS3DFormat sdm_s3d_format = kS3dFormatNone; 637 switch (s3d_format) { 638 case HAL_NO_3D: 639 sdm_s3d_format = kS3dFormatNone; 640 break; 641 case HAL_3D_SIDE_BY_SIDE_L_R: 642 sdm_s3d_format = kS3dFormatLeftRight; 643 break; 644 case HAL_3D_SIDE_BY_SIDE_R_L: 645 sdm_s3d_format = kS3dFormatRightLeft; 646 break; 647 case HAL_3D_TOP_BOTTOM: 648 sdm_s3d_format = kS3dFormatTopBottom; 649 break; 650 default: 651 DLOGW("Invalid S3D format %d", s3d_format); 652 } 653 return sdm_s3d_format; 654} 655 656DisplayError HWCLayer::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) { 657 LayerBuffer *layer_buffer = &layer->input_buffer; 658 private_handle_t *handle = const_cast<private_handle_t *>(pvt_handle); 659 IGC_t igc = {}; 660 LayerIGC layer_igc = layer_buffer->igc; 661 if (getMetaData(handle, GET_IGC, &igc) == 0) { 662 if (SetIGC(igc, &layer_igc) != kErrorNone) { 663 return kErrorNotSupported; 664 } 665 } 666 667 uint32_t fps = 0; 668 uint32_t frame_rate = layer->frame_rate; 669 if (getMetaData(handle, GET_REFRESH_RATE, &fps) == 0) { 670 frame_rate = RoundToStandardFPS(fps); 671 } 672 673 int32_t interlaced = 0; 674 bool interlace = layer_buffer->flags.interlace; 675 if (getMetaData(handle, GET_PP_PARAM_INTERLACED, &interlaced) == 0) { 676 interlace = interlaced ? true : false; 677 } 678 679 uint32_t linear_format = 0; 680 if (getMetaData(handle, GET_LINEAR_FORMAT, &linear_format) == 0) { 681 layer_buffer->format = GetSDMFormat(INT32(linear_format), 0); 682 } 683 684 uint32_t s3d = 0; 685 LayerBufferS3DFormat s3d_format = layer_buffer->s3d_format; 686 if (getMetaData(handle, GET_S3D_FORMAT, &s3d) == 0) { 687 s3d_format = GetS3DFormat(s3d); 688 } 689 690 if ((layer_igc != layer_buffer->igc) || (interlace != layer_buffer->flags.interlace) || 691 (frame_rate != layer->frame_rate) || (s3d_format != layer_buffer->s3d_format)) { 692 // Layer buffer metadata has changed. 693 needs_validate_ = true; 694 layer_buffer->igc = layer_igc; 695 layer->frame_rate = frame_rate; 696 layer_buffer->s3d_format = s3d_format; 697 layer_buffer->flags.interlace = interlace; 698 } 699 700 return kErrorNone; 701} 702 703DisplayError HWCLayer::SetIGC(IGC_t source, LayerIGC *target) { 704 switch (source) { 705 case IGC_NotSpecified: 706 *target = kIGCNotSpecified; 707 break; 708 case IGC_sRGB: 709 *target = kIGCsRGB; 710 break; 711 default: 712 DLOGE("Unsupported IGC: %d", source); 713 return kErrorNotSupported; 714 } 715 716 return kErrorNone; 717} 718 719 720 721bool HWCLayer::SupportLocalConversion(ColorPrimaries working_primaries) { 722 if (layer_->input_buffer.color_metadata.colorPrimaries <= ColorPrimaries_BT601_6_525 && 723 working_primaries <= ColorPrimaries_BT601_6_525) { 724 return true; 725 } 726 return false; 727} 728 729bool HWCLayer::ValidateAndSetCSC() { 730 if (client_requested_ != HWC2::Composition::Device && 731 client_requested_ != HWC2::Composition::Cursor) { 732 // Check the layers which are configured to Device 733 return true; 734 } 735 736 LayerBuffer *layer_buffer = &layer_->input_buffer; 737 bool use_color_metadata = true; 738#ifdef FEATURE_WIDE_COLOR 739 ColorMetaData csc = {}; 740 if (dataspace_ != HAL_DATASPACE_UNKNOWN) { 741 use_color_metadata = false; 742 bool valid_csc = GetSDMColorSpace(dataspace_, &csc); 743 if (!valid_csc) { 744 return false; 745 } 746 // if we are here here, update the sdm layer csc. 747 layer_buffer->color_metadata.transfer = csc.transfer; 748 layer_buffer->color_metadata.colorPrimaries = csc.colorPrimaries; 749 layer_buffer->color_metadata.range = csc.range; 750 } 751#endif 752 753 if (IsBT2020(layer_buffer->color_metadata.colorPrimaries)) { 754 // android_dataspace_t doesnt support mastering display and light levels 755 // so retrieve it from metadata for BT2020(HDR) 756 use_color_metadata = true; 757 } 758 759 if (use_color_metadata) { 760 const private_handle_t *handle = 761 reinterpret_cast<const private_handle_t *>(layer_buffer->buffer_id); 762 if (sdm::SetCSC(handle, &layer_buffer->color_metadata) != kErrorNone) { 763 return false; 764 } 765 } 766 767 return true; 768} 769 770 771uint32_t HWCLayer::RoundToStandardFPS(float fps) { 772 static const uint32_t standard_fps[4] = {24, 30, 48, 60}; 773 uint32_t frame_rate = (uint32_t)(fps); 774 775 int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0])); 776 for (int i = 0; i < count; i++) { 777 if ((standard_fps[i] - frame_rate) < 2) { 778 // Most likely used for video, the fps can fluctuate 779 // Ex: b/w 29 and 30 for 30 fps clip 780 return standard_fps[i]; 781 } 782 } 783 784 return frame_rate; 785} 786 787void HWCLayer::SetComposition(const LayerComposition &sdm_composition) { 788 auto hwc_composition = HWC2::Composition::Invalid; 789 switch (sdm_composition) { 790 case kCompositionGPU: 791 hwc_composition = HWC2::Composition::Client; 792 break; 793 case kCompositionHWCursor: 794 hwc_composition = HWC2::Composition::Cursor; 795 break; 796 default: 797 hwc_composition = HWC2::Composition::Device; 798 break; 799 } 800 // Update solid fill composition 801 if (sdm_composition == kCompositionSDE && layer_->flags.solid_fill != 0) { 802 hwc_composition = HWC2::Composition::SolidColor; 803 } 804 device_selected_ = hwc_composition; 805 806 return; 807} 808void HWCLayer::PushReleaseFence(int32_t fence) { 809 release_fences_.push(fence); 810} 811int32_t HWCLayer::PopReleaseFence(void) { 812 if (release_fences_.empty()) 813 return -1; 814 auto fence = release_fences_.front(); 815 release_fences_.pop(); 816 return fence; 817} 818 819} // namespace sdm 820