hwc_display.cpp revision 829790261efb161bff68251b0a1baceae6610430
1/* 2* Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved. 3* 4* Redistribution and use in source and binary forms, with or without 5* modification, are permitted provided that the following conditions are 6* met: 7* * Redistributions of source code must retain the above copyright 8* notice, this list of conditions and the following disclaimer. 9* * Redistributions in binary form must reproduce the above 10* copyright notice, this list of conditions and the following 11* disclaimer in the documentation and/or other materials provided 12* with the distribution. 13* * Neither the name of The Linux Foundation nor the names of its 14* contributors may be used to endorse or promote products derived 15* from this software without specific prior written permission. 16* 17* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 18* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 20* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 21* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 24* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 26* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28*/ 29 30#include <math.h> 31#include <errno.h> 32#include <gralloc_priv.h> 33#include <gr.h> 34#include <utils/constants.h> 35#include <utils/rect.h> 36#include <utils/debug.h> 37#include <sync/sync.h> 38#include <cutils/properties.h> 39#include <map> 40#include <utility> 41 42#include "hwc_display.h" 43#include "hwc_debugger.h" 44#include "blit_engine_c2d.h" 45 46#ifdef QTI_BSP 47#include <hardware/display_defs.h> 48#endif 49 50#define __CLASS__ "HWCDisplay" 51 52namespace sdm { 53 54static void ApplyDeInterlaceAdjustment(Layer *layer) { 55 // De-interlacing adjustment 56 if (layer->input_buffer->flags.interlace) { 57 float height = (layer->src_rect.bottom - layer->src_rect.top) / 2.0f; 58 layer->src_rect.top = ROUND_UP_ALIGN_DOWN(layer->src_rect.top / 2.0f, 2); 59 layer->src_rect.bottom = layer->src_rect.top + floorf(height); 60 } 61} 62 63HWCDisplay::HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type, 64 int id, bool needs_blit) 65 : core_intf_(core_intf), hwc_procs_(hwc_procs), type_(type), id_(id), needs_blit_(needs_blit) { 66} 67 68int HWCDisplay::Init() { 69 DisplayError error = core_intf_->CreateDisplay(type_, this, &display_intf_); 70 if (error != kErrorNone) { 71 DLOGE("Display create failed. Error = %d display_type %d event_handler %p disp_intf %p", 72 error, type_, this, &display_intf_); 73 return -EINVAL; 74 } 75 76 int property_swap_interval = 1; 77 HWCDebugHandler::Get()->GetProperty("debug.egl.swapinterval", &property_swap_interval); 78 if (property_swap_interval == 0) { 79 swap_interval_zero_ = true; 80 } 81 82 framebuffer_config_ = new DisplayConfigVariableInfo(); 83 if (!framebuffer_config_) { 84 DLOGV("Failed to allocate memory for custom framebuffer config."); 85 core_intf_->DestroyDisplay(display_intf_); 86 return -EINVAL; 87 } 88 89 if (needs_blit_) { 90 blit_engine_ = new BlitEngineC2d(); 91 if (!blit_engine_) { 92 DLOGI("Create Blit Engine C2D failed"); 93 } else { 94 if (blit_engine_->Init() < 0) { 95 DLOGI("Blit Engine Init failed, Blit Composition will not be used!!"); 96 delete blit_engine_; 97 blit_engine_ = NULL; 98 } 99 } 100 } 101 102 display_intf_->GetRefreshRateRange(&min_refresh_rate_, &max_refresh_rate_); 103 current_refresh_rate_ = max_refresh_rate_; 104 105 s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_NO_3D, kS3dFormatNone)); 106 s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_3D_SIDE_BY_SIDE_L_R, 107 kS3dFormatLeftRight)); 108 s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_3D_SIDE_BY_SIDE_R_L, 109 kS3dFormatRightLeft)); 110 s3d_format_hwc_to_sdm_.insert(std::pair<int, LayerBufferS3DFormat>(HAL_3D_TOP_BOTTOM, 111 kS3dFormatTopBottom)); 112 113 return 0; 114} 115 116int HWCDisplay::Deinit() { 117 DisplayError error = core_intf_->DestroyDisplay(display_intf_); 118 if (error != kErrorNone) { 119 DLOGE("Display destroy failed. Error = %d", error); 120 return -EINVAL; 121 } 122 123 DeallocateLayerStack(); 124 125 delete framebuffer_config_; 126 127 if (blit_engine_) { 128 blit_engine_->DeInit(); 129 delete blit_engine_; 130 blit_engine_ = NULL; 131 } 132 133 return 0; 134} 135 136int HWCDisplay::EventControl(int event, int enable) { 137 DisplayError error = kErrorNone; 138 139 if (shutdown_pending_) { 140 return 0; 141 } 142 143 switch (event) { 144 case HWC_EVENT_VSYNC: 145 error = display_intf_->SetVSyncState(enable); 146 break; 147 default: 148 DLOGW("Unsupported event = %d", event); 149 } 150 151 if (error != kErrorNone) { 152 if (error == kErrorShutDown) { 153 shutdown_pending_ = true; 154 return 0; 155 } 156 DLOGE("Failed. event = %d, enable = %d, error = %d", event, enable, error); 157 return -EINVAL; 158 } 159 160 return 0; 161} 162 163int HWCDisplay::SetPowerMode(int mode) { 164 DLOGI("display = %d, mode = %d", id_, mode); 165 DisplayState state = kStateOff; 166 bool flush_on_error = flush_on_error_; 167 168 if (shutdown_pending_) { 169 return 0; 170 } 171 172 switch (mode) { 173 case HWC_POWER_MODE_OFF: 174 // During power off, all of the buffers are released. 175 // Do not flush until a buffer is successfully submitted again. 176 flush_on_error = false; 177 state = kStateOff; 178 break; 179 180 case HWC_POWER_MODE_NORMAL: 181 state = kStateOn; 182 last_power_mode_ = HWC_POWER_MODE_NORMAL; 183 break; 184 185 case HWC_POWER_MODE_DOZE: 186 state = kStateDoze; 187 last_power_mode_ = HWC_POWER_MODE_DOZE; 188 break; 189 190 case HWC_POWER_MODE_DOZE_SUSPEND: 191 state = kStateDozeSuspend; 192 last_power_mode_ = HWC_POWER_MODE_DOZE_SUSPEND; 193 break; 194 195 default: 196 return -EINVAL; 197 } 198 199 DisplayError error = display_intf_->SetDisplayState(state); 200 if (error == kErrorNone) { 201 flush_on_error_ = flush_on_error; 202 } else { 203 if (error == kErrorShutDown) { 204 shutdown_pending_ = true; 205 return 0; 206 } 207 DLOGE("Set state failed. Error = %d", error); 208 return -EINVAL; 209 } 210 211 return 0; 212} 213 214int HWCDisplay::GetDisplayConfigs(uint32_t *configs, size_t *num_configs) { 215 if (*num_configs > 0) { 216 configs[0] = 0; 217 *num_configs = 1; 218 } 219 220 return 0; 221} 222 223int HWCDisplay::GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values) { 224 DisplayConfigVariableInfo variable_config = *framebuffer_config_; 225 226 for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++) { 227 switch (attributes[i]) { 228 case HWC_DISPLAY_VSYNC_PERIOD: 229 values[i] = variable_config.vsync_period_ns; 230 break; 231 case HWC_DISPLAY_WIDTH: 232 values[i] = variable_config.x_pixels; 233 break; 234 case HWC_DISPLAY_HEIGHT: 235 values[i] = variable_config.y_pixels; 236 break; 237 case HWC_DISPLAY_DPI_X: 238 values[i] = INT32(variable_config.x_dpi * 1000.0f); 239 break; 240 case HWC_DISPLAY_DPI_Y: 241 values[i] = INT32(variable_config.y_dpi * 1000.0f); 242 break; 243 default: 244 DLOGW("Spurious attribute type = %d", attributes[i]); 245 return -EINVAL; 246 } 247 } 248 249 return 0; 250} 251 252int HWCDisplay::GetActiveConfig() { 253 return 0; 254} 255 256int HWCDisplay::SetActiveConfig(int index) { 257 return -1; 258} 259 260void HWCDisplay::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type) { 261 dump_frame_count_ = count; 262 dump_frame_index_ = 0; 263 dump_input_layers_ = ((bit_mask_layer_type & (1 << INPUT_LAYER_DUMP)) != 0); 264 265 if (blit_engine_) { 266 blit_engine_->SetFrameDumpConfig(count); 267 } 268 269 DLOGI("num_frame_dump %d, input_layer_dump_enable %d", dump_frame_count_, dump_input_layers_); 270} 271 272uint32_t HWCDisplay::GetLastPowerMode() { 273 return last_power_mode_; 274} 275 276DisplayError HWCDisplay::VSync(const DisplayEventVSync &vsync) { 277 const hwc_procs_t *hwc_procs = *hwc_procs_; 278 279 if (!hwc_procs) { 280 return kErrorParameters; 281 } 282 283 hwc_procs->vsync(hwc_procs, id_, vsync.timestamp); 284 285 return kErrorNone; 286} 287 288DisplayError HWCDisplay::Refresh() { 289 return kErrorNotSupported; 290} 291 292int HWCDisplay::AllocateLayerStack(hwc_display_contents_1_t *content_list) { 293 if (!content_list || !content_list->numHwLayers) { 294 DLOGW("Invalid content list"); 295 return -EINVAL; 296 } 297 298 DeallocateLayerStack(); 299 300 size_t num_hw_layers = content_list->numHwLayers; 301 uint32_t blit_target_count = 0; 302 303 if (needs_blit_ && blit_engine_) { 304 blit_target_count = kMaxBlitTargetLayers; 305 } 306 307 layer_stack_.layer_count = UINT32(num_hw_layers + blit_target_count); 308 layer_stack_.layers = new Layer[layer_stack_.layer_count]; 309 if (!layer_stack_.layers) { 310 return -ENOMEM; 311 } 312 313 for (size_t i = 0; i < layer_stack_.layer_count; i++) { 314 uint32_t num_visible_rects = 0; 315 uint32_t num_dirty_rects = 0; 316 317 hwc_layer_1_t &hwc_layer = content_list->hwLayers[i]; 318 Layer &layer = layer_stack_.layers[i]; 319 320 layer.input_buffer = new LayerBuffer; 321 if (!layer.input_buffer) { 322 return -ENOMEM; 323 } 324 325 if (i < num_hw_layers) { 326 num_visible_rects = hwc_layer.visibleRegionScreen.numRects; 327 num_dirty_rects = hwc_layer.surfaceDamage.numRects; 328 } 329 330 if (num_visible_rects) { 331 layer.visible_regions.rect = new LayerRect[num_visible_rects]; 332 if (!layer.visible_regions.rect) { 333 return -ENOMEM; 334 } 335 layer.visible_regions.count = num_visible_rects; 336 } 337 338 if (num_dirty_rects) { 339 layer.dirty_regions.rect = new LayerRect[num_dirty_rects]; 340 if (!layer.dirty_regions.rect) { 341 return -ENOMEM; 342 } 343 layer.dirty_regions.count = num_dirty_rects; 344 } 345 346 if (blit_target_count) { 347 layer.blit_regions.rect = new LayerRect[blit_target_count]; 348 if (!layer.blit_regions.rect) { 349 return -ENOMEM; 350 } 351 layer.blit_regions.count = blit_target_count; 352 } 353 } 354 355 return 0; 356} 357 358void HWCDisplay::DeallocateLayerStack() { 359 if (!layer_stack_.layers) { 360 return; 361 } 362 363 for (size_t i = 0; i < layer_stack_.layer_count; i++) { 364 Layer &layer = layer_stack_.layers[i]; 365 366 delete layer.input_buffer; 367 delete[] layer.visible_regions.rect; 368 delete[] layer.dirty_regions.rect; 369 delete[] layer.blit_regions.rect; 370 } 371 372 delete[] layer_stack_.layers; 373 374 // Reset layer stack to default values always. This will ensure that calling 375 // Allocate or Deallocate method twice does not result in unexpected behavior. 376 layer_stack_ = LayerStack(); 377} 378 379int HWCDisplay::PrepareLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer) { 380 const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer->handle); 381 382 LayerBuffer *layer_buffer = layer->input_buffer; 383 384 if (pvt_handle) { 385 layer_buffer->format = GetSDMFormat(pvt_handle->format, pvt_handle->flags); 386 layer_buffer->width = pvt_handle->width; 387 layer_buffer->height = pvt_handle->height; 388 389 if (SetMetaData(pvt_handle, layer) != kErrorNone) { 390 return -EINVAL; 391 } 392 393 if (pvt_handle->bufferType == BUFFER_TYPE_VIDEO) { 394 layer_stack_.flags.video_present = true; 395 layer_buffer->flags.video = true; 396 } 397 // TZ Protected Buffer - L1 398 if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) { 399 layer_stack_.flags.secure_present = true; 400 layer_buffer->flags.secure = true; 401 } 402 // Gralloc Usage Protected Buffer - L3 - which needs to be treated as Secure & avoid fallback 403 if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_PROTECTED_BUFFER) { 404 layer_stack_.flags.secure_present = true; 405 } 406 if (pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY) { 407 layer_buffer->flags.secure_display = true; 408 } 409 410 // check if this is special solid_fill layer without input_buffer. 411 if (solid_fill_enable_ && pvt_handle->fd == -1) { 412 layer->flags.solid_fill = true; 413 layer->solid_fill_color = solid_fill_color_; 414 } 415 } else { 416 // for FBT layer 417 if (hwc_layer->compositionType == HWC_FRAMEBUFFER_TARGET) { 418 uint32_t x_pixels; 419 uint32_t y_pixels; 420 int aligned_width; 421 int aligned_height; 422 int usage = GRALLOC_USAGE_HW_FB; 423 int format = HAL_PIXEL_FORMAT_RGBA_8888; 424 int ubwc_enabled = 0; 425 int flags = 0; 426 HWCDebugHandler::Get()->GetProperty("debug.gralloc.enable_fb_ubwc", &ubwc_enabled); 427 if (ubwc_enabled == 1) { 428 usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC; 429 flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED; 430 } 431 432 GetFrameBufferResolution(&x_pixels, &y_pixels); 433 434 AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(INT(x_pixels), INT(y_pixels), format, 435 usage, aligned_width, aligned_height); 436 layer_buffer->width = aligned_width; 437 layer_buffer->height = aligned_height; 438 layer_buffer->format = GetSDMFormat(format, flags); 439 } 440 } 441 442 return 0; 443} 444 445void HWCDisplay::CommitLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer) { 446 const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer->handle); 447 LayerBuffer *layer_buffer = layer->input_buffer; 448 449 if (pvt_handle) { 450 layer_buffer->planes[0].fd = pvt_handle->fd; 451 layer_buffer->planes[0].offset = pvt_handle->offset; 452 layer_buffer->planes[0].stride = pvt_handle->width; 453 } 454 455 // if swapinterval property is set to 0 then close and reset the acquireFd 456 if (swap_interval_zero_ && hwc_layer->acquireFenceFd >= 0) { 457 close(hwc_layer->acquireFenceFd); 458 hwc_layer->acquireFenceFd = -1; 459 } 460 layer_buffer->acquire_fence_fd = hwc_layer->acquireFenceFd; 461} 462 463int HWCDisplay::PrePrepareLayerStack(hwc_display_contents_1_t *content_list) { 464 if (shutdown_pending_) { 465 return 0; 466 } 467 468 if (!content_list || !content_list->numHwLayers) { 469 DLOGW("Invalid content list"); 470 return -EINVAL; 471 } 472 473 size_t num_hw_layers = content_list->numHwLayers; 474 475 use_blit_comp_ = false; 476 metadata_refresh_rate_ = 0; 477 display_rect_ = LayerRect(); 478 479 // Configure each layer 480 for (size_t i = 0; i < num_hw_layers; i++) { 481 hwc_layer_1_t &hwc_layer = content_list->hwLayers[i]; 482 483 Layer &layer = layer_stack_.layers[i]; 484 485 int ret = PrepareLayerParams(&content_list->hwLayers[i], &layer_stack_.layers[i]); 486 487 if (ret != kErrorNone) { 488 return ret; 489 } 490 491 layer.flags.skip = ((hwc_layer.flags & HWC_SKIP_LAYER) > 0); 492 layer.flags.solid_fill = (hwc_layer.flags & kDimLayer) || solid_fill_enable_; 493 if (layer.flags.skip || layer.flags.solid_fill) { 494 layer.dirty_regions.count = 0; 495 } 496 497 hwc_rect_t scaled_display_frame = hwc_layer.displayFrame; 498 ScaleDisplayFrame(&scaled_display_frame); 499 ApplyScanAdjustment(&scaled_display_frame); 500 501 SetRect(scaled_display_frame, &layer.dst_rect); 502 SetRect(hwc_layer.sourceCropf, &layer.src_rect); 503 ApplyDeInterlaceAdjustment(&layer); 504 505 for (uint32_t j = 0; j < layer.visible_regions.count; j++) { 506 SetRect(hwc_layer.visibleRegionScreen.rects[j], &layer.visible_regions.rect[j]); 507 } 508 for (uint32_t j = 0; j < layer.dirty_regions.count; j++) { 509 SetRect(hwc_layer.surfaceDamage.rects[j], &layer.dirty_regions.rect[j]); 510 } 511 SetComposition(hwc_layer.compositionType, &layer.composition); 512 513 if (hwc_layer.compositionType != HWC_FRAMEBUFFER_TARGET) { 514 display_rect_ = Union(display_rect_, layer.dst_rect); 515 } 516 517 518 // For dim layers, SurfaceFlinger 519 // - converts planeAlpha to per pixel alpha, 520 // - sets RGB color to 000, 521 // - sets planeAlpha to 0xff, 522 // - blending to Premultiplied. 523 // This can be achieved at hardware by 524 // - solid fill ARGB to 0xff000000, 525 // - incoming planeAlpha, 526 // - blending to Coverage. 527 if (hwc_layer.flags & kDimLayer) { 528 layer.input_buffer->format = kFormatARGB8888; 529 layer.solid_fill_color = 0xff000000; 530 SetBlending(HWC_BLENDING_COVERAGE, &layer.blending); 531 } else { 532 SetBlending(hwc_layer.blending, &layer.blending); 533 LayerTransform &layer_transform = layer.transform; 534 uint32_t &hwc_transform = hwc_layer.transform; 535 layer_transform.flip_horizontal = ((hwc_transform & HWC_TRANSFORM_FLIP_H) > 0); 536 layer_transform.flip_vertical = ((hwc_transform & HWC_TRANSFORM_FLIP_V) > 0); 537 layer_transform.rotation = ((hwc_transform & HWC_TRANSFORM_ROT_90) ? 90.0f : 0.0f); 538 } 539 540 // TODO(user): Remove below block. 541 // For solid fill, only dest rect need to be specified. 542 if (layer.flags.solid_fill) { 543 LayerBuffer *input_buffer = layer.input_buffer; 544 input_buffer->width = layer.dst_rect.right - layer.dst_rect.left; 545 input_buffer->height = layer.dst_rect.bottom - layer.dst_rect.top; 546 layer.src_rect.left = 0; 547 layer.src_rect.top = 0; 548 layer.src_rect.right = input_buffer->width; 549 layer.src_rect.bottom = input_buffer->height; 550 } 551 552 layer.plane_alpha = hwc_layer.planeAlpha; 553 layer.flags.cursor = ((hwc_layer.flags & HWC_IS_CURSOR_LAYER) > 0); 554 layer.flags.updating = true; 555 556 if (num_hw_layers <= kMaxLayerCount) { 557 layer.flags.updating = IsLayerUpdating(content_list, i); 558 } 559#ifdef QTI_BSP 560 if (hwc_layer.flags & HWC_SCREENSHOT_ANIMATOR_LAYER) { 561 layer_stack_.flags.animating = true; 562 } 563#endif 564 if (layer.flags.skip) { 565 layer_stack_.flags.skip_present = true; 566 } 567 568 if (layer.flags.cursor) { 569 layer_stack_.flags.cursor_present = true; 570 } 571 572 if (layer.frame_rate > metadata_refresh_rate_) { 573 metadata_refresh_rate_ = SanitizeRefreshRate(layer.frame_rate); 574 } else { 575 layer.frame_rate = current_refresh_rate_; 576 } 577 578 layer.input_buffer->buffer_id = reinterpret_cast<uint64_t>(hwc_layer.handle); 579 } 580 581 // Prepare the Blit Target 582 if (blit_engine_) { 583 int ret = blit_engine_->Prepare(&layer_stack_); 584 if (ret) { 585 // Blit engine cannot handle this layer stack, hence set the layer stack 586 // count to num_hw_layers 587 layer_stack_.layer_count -= kMaxBlitTargetLayers; 588 } else { 589 use_blit_comp_ = true; 590 } 591 } 592 593 // Configure layer stack 594 layer_stack_.flags.geometry_changed = ((content_list->flags & HWC_GEOMETRY_CHANGED) > 0); 595 596 return 0; 597} 598 599int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) { 600 if (shutdown_pending_) { 601 return 0; 602 } 603 604 size_t num_hw_layers = content_list->numHwLayers; 605 606 if (!skip_prepare_) { 607 DisplayError error = display_intf_->Prepare(&layer_stack_); 608 if (error != kErrorNone) { 609 if (error == kErrorShutDown) { 610 shutdown_pending_ = true; 611 } else if (error != kErrorPermission) { 612 DLOGE("Prepare failed. Error = %d", error); 613 // To prevent surfaceflinger infinite wait, flush the previous frame during Commit() 614 // so that previous buffer and fences are released, and override the error. 615 flush_ = true; 616 } 617 618 return 0; 619 } 620 } else { 621 // Skip is not set 622 MarkLayersForGPUBypass(content_list); 623 skip_prepare_ = false; 624 DLOGI("SecureDisplay %s, Skip Prepare/Commit and Flush", secure_display_active_ ? "Starting" : 625 "Stopping"); 626 flush_ = true; 627 } 628 629 // If current draw cycle has different set of layers updating in comparison to previous cycle, 630 // cache content using GPU again. 631 // If set of updating layers remains same, use cached buffer and replace layers marked for GPU 632 // composition with SDE so that SurfaceFlinger does not compose them. Set cache inuse here. 633 bool needs_fb_refresh = NeedsFrameBufferRefresh(content_list); 634 layer_stack_cache_.in_use = false; 635 636 for (size_t i = 0; i < num_hw_layers; i++) { 637 hwc_layer_1_t &hwc_layer = content_list->hwLayers[i]; 638 Layer &layer = layer_stack_.layers[i]; 639 LayerComposition composition = layer.composition; 640 641 if ((composition == kCompositionSDE) || (composition == kCompositionHybrid) || 642 (composition == kCompositionBlit)) { 643 hwc_layer.hints |= HWC_HINT_CLEAR_FB; 644 } 645 646 if (!needs_fb_refresh && composition == kCompositionGPU) { 647 composition = kCompositionSDE; 648 layer_stack_cache_.in_use = true; 649 } 650 SetComposition(composition, &hwc_layer.compositionType); 651 } 652 653 CacheLayerStackInfo(content_list); 654 655 return 0; 656} 657 658int HWCDisplay::CommitLayerStack(hwc_display_contents_1_t *content_list) { 659 if (!content_list || !content_list->numHwLayers) { 660 DLOGW("Invalid content list"); 661 return -EINVAL; 662 } 663 664 if (shutdown_pending_) { 665 return 0; 666 } 667 668 int status = 0; 669 670 size_t num_hw_layers = content_list->numHwLayers; 671 672 DumpInputBuffers(content_list); 673 674 if (!flush_) { 675 for (size_t i = 0; i < num_hw_layers; i++) { 676 CommitLayerParams(&content_list->hwLayers[i], &layer_stack_.layers[i]); 677 } 678 679 if (use_blit_comp_) { 680 status = blit_engine_->PreCommit(content_list, &layer_stack_); 681 if (status == 0) { 682 status = blit_engine_->Commit(content_list, &layer_stack_); 683 if (status != 0) { 684 DLOGE("Blit Comp Failed!"); 685 } 686 } 687 } 688 689 DisplayError error = kErrorUndefined; 690 if (status == 0) { 691 error = display_intf_->Commit(&layer_stack_); 692 status = 0; 693 } 694 695 if (error == kErrorNone) { 696 // A commit is successfully submitted, start flushing on failure now onwards. 697 flush_on_error_ = true; 698 } else { 699 if (error == kErrorShutDown) { 700 shutdown_pending_ = true; 701 return status; 702 } else if (error != kErrorPermission) { 703 DLOGE("Commit failed. Error = %d", error); 704 // To prevent surfaceflinger infinite wait, flush the previous frame during Commit() 705 // so that previous buffer and fences are released, and override the error. 706 flush_ = true; 707 } 708 } 709 } 710 711 return status; 712} 713 714int HWCDisplay::PostCommitLayerStack(hwc_display_contents_1_t *content_list) { 715 size_t num_hw_layers = content_list->numHwLayers; 716 int status = 0; 717 718 // Do no call flush on errors, if a successful buffer is never submitted. 719 if (flush_ && flush_on_error_) { 720 display_intf_->Flush(); 721 } 722 723 // Set the release fence fd to the blit engine 724 if (use_blit_comp_ && blit_engine_->BlitActive()) { 725 blit_engine_->PostCommit(&layer_stack_); 726 } 727 728 for (size_t i = 0; i < num_hw_layers; i++) { 729 hwc_layer_1_t &hwc_layer = content_list->hwLayers[i]; 730 Layer &layer = layer_stack_.layers[i]; 731 LayerBuffer *layer_buffer = layer_stack_.layers[i].input_buffer; 732 733 if (!flush_) { 734 // If swapinterval property is set to 0 or for single buffer layers, do not update f/w 735 // release fences and discard fences from driver 736 if (swap_interval_zero_ || layer.flags.single_buffer) { 737 hwc_layer.releaseFenceFd = -1; 738 close(layer_buffer->release_fence_fd); 739 layer_buffer->release_fence_fd = -1; 740 } else if (layer.composition != kCompositionGPU) { 741 hwc_layer.releaseFenceFd = layer_buffer->release_fence_fd; 742 } 743 744 // During animation on external/virtual display, SDM will use the cached 745 // framebuffer layer throughout animation and do not allow framework to do eglswapbuffer on 746 // framebuffer target. So graphics doesn't close the release fence fd of framebuffer target, 747 // Hence close the release fencefd of framebuffer target here. 748 if (layer.composition == kCompositionGPUTarget && layer_stack_cache_.animating) { 749 close(hwc_layer.releaseFenceFd); 750 hwc_layer.releaseFenceFd = -1; 751 } 752 } 753 754 if (hwc_layer.acquireFenceFd >= 0) { 755 close(hwc_layer.acquireFenceFd); 756 hwc_layer.acquireFenceFd = -1; 757 } 758 } 759 760 if (!flush_) { 761 layer_stack_cache_.animating = layer_stack_.flags.animating; 762 763 // if swapinterval property is set to 0 then close and reset the list retire fence 764 if (swap_interval_zero_) { 765 close(layer_stack_.retire_fence_fd); 766 layer_stack_.retire_fence_fd = -1; 767 } 768 content_list->retireFenceFd = layer_stack_.retire_fence_fd; 769 770 if (dump_frame_count_) { 771 dump_frame_count_--; 772 dump_frame_index_++; 773 } 774 } 775 776 flush_ = false; 777 778 return status; 779} 780 781 782bool HWCDisplay::NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list) { 783 uint32_t layer_count = layer_stack_.layer_count; 784 785 // Handle ongoing animation and end here, start is handled below 786 if (layer_stack_cache_.animating) { 787 if (!layer_stack_.flags.animating) { 788 // Animation is ending. 789 return true; 790 } else { 791 // Animation is going on. 792 return false; 793 } 794 } 795 796 // Frame buffer needs to be refreshed for the following reasons: 797 // 1. Any layer is marked skip in the current layer stack. 798 // 2. Any layer is added/removed/layer properties changes in the current layer stack. 799 // 3. Any layer handle is changed and it is marked for GPU composition 800 // 4. Any layer's current composition is different from previous composition. 801 if (layer_stack_.flags.skip_present || layer_stack_.flags.geometry_changed) { 802 return true; 803 } 804 805 for (uint32_t i = 0; i < layer_count; i++) { 806 Layer &layer = layer_stack_.layers[i]; 807 LayerCache &layer_cache = layer_stack_cache_.layer_cache[i]; 808 809 // need FB refresh for s3d case 810 if (layer.input_buffer->s3d_format != kS3dFormatNone) { 811 return true; 812 } 813 814 if (layer.composition == kCompositionGPUTarget) { 815 continue; 816 } 817 818 if (layer_cache.composition != layer.composition) { 819 return true; 820 } 821 822 if ((layer.composition == kCompositionGPU) && IsLayerUpdating(content_list, i)) { 823 return true; 824 } 825 } 826 827 return false; 828} 829 830bool HWCDisplay::IsLayerUpdating(hwc_display_contents_1_t *content_list, int layer_index) { 831 hwc_layer_1_t &hwc_layer = content_list->hwLayers[layer_index]; 832 LayerCache &layer_cache = layer_stack_cache_.layer_cache[layer_index]; 833 834 const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer.handle); 835 const MetaData_t *meta_data = pvt_handle ? 836 reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata) : NULL; 837 838 // Layer should be considered updating if 839 // a) layer is in single buffer mode, or 840 // b) layer handle has changed, or 841 // c) layer plane alpha has changed, or 842 // d) layer stack geometry has changed 843 return ((meta_data && (meta_data->operation & SET_SINGLE_BUFFER_MODE) && 844 meta_data->isSingleBufferMode) || 845 (layer_cache.handle != hwc_layer.handle) || 846 (layer_cache.plane_alpha != hwc_layer.planeAlpha) || 847 (content_list->flags & HWC_GEOMETRY_CHANGED)); 848} 849 850void HWCDisplay::CacheLayerStackInfo(hwc_display_contents_1_t *content_list) { 851 uint32_t layer_count = layer_stack_.layer_count; 852 853 if (layer_count > kMaxLayerCount || layer_stack_.flags.animating) { 854 ResetLayerCacheStack(); 855 return; 856 } 857 858 for (uint32_t i = 0; i < layer_count; i++) { 859 Layer &layer = layer_stack_.layers[i]; 860 if (layer.composition == kCompositionGPUTarget || 861 layer.composition == kCompositionBlitTarget) { 862 continue; 863 } 864 865 LayerCache &layer_cache = layer_stack_cache_.layer_cache[i]; 866 layer_cache.handle = content_list->hwLayers[i].handle; 867 layer_cache.plane_alpha = content_list->hwLayers[i].planeAlpha; 868 layer_cache.composition = layer.composition; 869 } 870 871 layer_stack_cache_.layer_count = layer_count; 872} 873 874void HWCDisplay::SetRect(const hwc_rect_t &source, LayerRect *target) { 875 target->left = FLOAT(source.left); 876 target->top = FLOAT(source.top); 877 target->right = FLOAT(source.right); 878 target->bottom = FLOAT(source.bottom); 879} 880 881void HWCDisplay::SetRect(const hwc_frect_t &source, LayerRect *target) { 882 target->left = floorf(source.left); 883 target->top = floorf(source.top); 884 target->right = ceilf(source.right); 885 target->bottom = ceilf(source.bottom); 886} 887 888void HWCDisplay::SetComposition(const int32_t &source, LayerComposition *target) { 889 switch (source) { 890 case HWC_FRAMEBUFFER_TARGET: *target = kCompositionGPUTarget; break; 891 default: *target = kCompositionGPU; break; 892 } 893} 894 895void HWCDisplay::SetComposition(const LayerComposition &source, int32_t *target) { 896 switch (source) { 897 case kCompositionGPUTarget: *target = HWC_FRAMEBUFFER_TARGET; break; 898 case kCompositionGPU: *target = HWC_FRAMEBUFFER; break; 899 case kCompositionHWCursor: *target = HWC_CURSOR_OVERLAY; break; 900 default: *target = HWC_OVERLAY; break; 901 } 902} 903 904void HWCDisplay::SetBlending(const int32_t &source, LayerBlending *target) { 905 switch (source) { 906 case HWC_BLENDING_PREMULT: *target = kBlendingPremultiplied; break; 907 case HWC_BLENDING_COVERAGE: *target = kBlendingCoverage; break; 908 default: *target = kBlendingOpaque; break; 909 } 910} 911 912void HWCDisplay::SetIdleTimeoutMs(uint32_t timeout_ms) { 913 return; 914} 915 916DisplayError HWCDisplay::SetMaxMixerStages(uint32_t max_mixer_stages) { 917 DisplayError error = kErrorNone; 918 919 if (display_intf_) { 920 error = display_intf_->SetMaxMixerStages(max_mixer_stages); 921 } 922 923 return error; 924} 925 926DisplayError HWCDisplay::ControlPartialUpdate(bool enable, uint32_t *pending) { 927 DisplayError error = kErrorNone; 928 929 if (display_intf_) { 930 error = display_intf_->ControlPartialUpdate(enable, pending); 931 } 932 933 return error; 934} 935 936LayerBufferFormat HWCDisplay::GetSDMFormat(const int32_t &source, const int flags) { 937 LayerBufferFormat format = kFormatInvalid; 938 if (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) { 939 switch (source) { 940 case HAL_PIXEL_FORMAT_RGBA_8888: format = kFormatRGBA8888Ubwc; break; 941 case HAL_PIXEL_FORMAT_RGBX_8888: format = kFormatRGBX8888Ubwc; break; 942 case HAL_PIXEL_FORMAT_BGR_565: format = kFormatBGR565Ubwc; break; 943 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS: 944 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC: 945 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: format = kFormatYCbCr420SPVenusUbwc; break; 946 default: 947 DLOGE("Unsupported format type for UBWC %d", source); 948 return kFormatInvalid; 949 } 950 return format; 951 } 952 953 switch (source) { 954 case HAL_PIXEL_FORMAT_RGBA_8888: format = kFormatRGBA8888; break; 955 case HAL_PIXEL_FORMAT_RGBA_5551: format = kFormatRGBA5551; break; 956 case HAL_PIXEL_FORMAT_RGBA_4444: format = kFormatRGBA4444; break; 957 case HAL_PIXEL_FORMAT_BGRA_8888: format = kFormatBGRA8888; break; 958 case HAL_PIXEL_FORMAT_RGBX_8888: format = kFormatRGBX8888; break; 959 case HAL_PIXEL_FORMAT_BGRX_8888: format = kFormatBGRX8888; break; 960 case HAL_PIXEL_FORMAT_RGB_888: format = kFormatRGB888; break; 961 case HAL_PIXEL_FORMAT_RGB_565: format = kFormatRGB565; break; 962 case HAL_PIXEL_FORMAT_BGR_565: format = kFormatBGR565; break; 963 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 964 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS: format = kFormatYCbCr420SemiPlanarVenus; break; 965 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS: format = kFormatYCrCb420SemiPlanarVenus; break; 966 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC: format = kFormatYCbCr420SPVenusUbwc; break; 967 case HAL_PIXEL_FORMAT_YV12: format = kFormatYCrCb420PlanarStride16; break; 968 case HAL_PIXEL_FORMAT_YCrCb_420_SP: format = kFormatYCrCb420SemiPlanar; break; 969 case HAL_PIXEL_FORMAT_YCbCr_420_SP: format = kFormatYCbCr420SemiPlanar; break; 970 case HAL_PIXEL_FORMAT_YCbCr_422_SP: format = kFormatYCbCr422H2V1SemiPlanar; break; 971 case HAL_PIXEL_FORMAT_YCbCr_422_I: format = kFormatYCbCr422H2V1Packed; break; 972 default: 973 DLOGW("Unsupported format type = %d", source); 974 return kFormatInvalid; 975 } 976 977 return format; 978} 979 980void HWCDisplay::DumpInputBuffers(hwc_display_contents_1_t *content_list) { 981 size_t num_hw_layers = content_list->numHwLayers; 982 char dir_path[PATH_MAX]; 983 984 if (!dump_frame_count_ || flush_ || !dump_input_layers_) { 985 return; 986 } 987 988 snprintf(dir_path, sizeof(dir_path), "/data/misc/display/frame_dump_%s", GetDisplayString()); 989 990 if (mkdir(dir_path, 0777) != 0 && errno != EEXIST) { 991 DLOGW("Failed to create %s directory errno = %d, desc = %s", dir_path, errno, strerror(errno)); 992 return; 993 } 994 995 // if directory exists already, need to explicitly change the permission. 996 if (errno == EEXIST && chmod(dir_path, 0777) != 0) { 997 DLOGW("Failed to change permissions on %s directory", dir_path); 998 return; 999 } 1000 1001 for (uint32_t i = 0; i < num_hw_layers; i++) { 1002 hwc_layer_1_t &hwc_layer = content_list->hwLayers[i]; 1003 const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer.handle); 1004 1005 if (hwc_layer.acquireFenceFd >= 0) { 1006 int error = sync_wait(hwc_layer.acquireFenceFd, 1000); 1007 if (error < 0) { 1008 DLOGW("sync_wait error errno = %d, desc = %s", errno, strerror(errno)); 1009 return; 1010 } 1011 } 1012 1013 if (pvt_handle && pvt_handle->base) { 1014 char dump_file_name[PATH_MAX]; 1015 size_t result = 0; 1016 1017 snprintf(dump_file_name, sizeof(dump_file_name), "%s/input_layer%d_%dx%d_%s_frame%d.raw", 1018 dir_path, i, pvt_handle->width, pvt_handle->height, 1019 GetHALPixelFormatString(pvt_handle->format), dump_frame_index_); 1020 1021 FILE* fp = fopen(dump_file_name, "w+"); 1022 if (fp) { 1023 result = fwrite(reinterpret_cast<void *>(pvt_handle->base), pvt_handle->size, 1, fp); 1024 fclose(fp); 1025 } 1026 1027 DLOGI("Frame Dump %s: is %s", dump_file_name, result ? "Successful" : "Failed"); 1028 } 1029 } 1030} 1031 1032const char *HWCDisplay::GetHALPixelFormatString(int format) { 1033 switch (format) { 1034 case HAL_PIXEL_FORMAT_RGBA_8888: 1035 return "RGBA_8888"; 1036 case HAL_PIXEL_FORMAT_RGBX_8888: 1037 return "RGBX_8888"; 1038 case HAL_PIXEL_FORMAT_RGB_888: 1039 return "RGB_888"; 1040 case HAL_PIXEL_FORMAT_RGB_565: 1041 return "RGB_565"; 1042 case HAL_PIXEL_FORMAT_BGR_565: 1043 return "BGR_565"; 1044 case HAL_PIXEL_FORMAT_BGRA_8888: 1045 return "BGRA_8888"; 1046 case HAL_PIXEL_FORMAT_RGBA_5551: 1047 return "RGBA_5551"; 1048 case HAL_PIXEL_FORMAT_RGBA_4444: 1049 return "RGBA_4444"; 1050 case HAL_PIXEL_FORMAT_YV12: 1051 return "YV12"; 1052 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 1053 return "YCbCr_422_SP_NV16"; 1054 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 1055 return "YCrCb_420_SP_NV21"; 1056 case HAL_PIXEL_FORMAT_YCbCr_422_I: 1057 return "YCbCr_422_I_YUY2"; 1058 case HAL_PIXEL_FORMAT_YCrCb_422_I: 1059 return "YCrCb_422_I_YVYU"; 1060 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 1061 return "NV12_ENCODEABLE"; 1062 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: 1063 return "YCbCr_420_SP_TILED_TILE_4x2"; 1064 case HAL_PIXEL_FORMAT_YCbCr_420_SP: 1065 return "YCbCr_420_SP"; 1066 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO: 1067 return "YCrCb_420_SP_ADRENO"; 1068 case HAL_PIXEL_FORMAT_YCrCb_422_SP: 1069 return "YCrCb_422_SP"; 1070 case HAL_PIXEL_FORMAT_R_8: 1071 return "R_8"; 1072 case HAL_PIXEL_FORMAT_RG_88: 1073 return "RG_88"; 1074 case HAL_PIXEL_FORMAT_INTERLACE: 1075 return "INTERLACE"; 1076 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS: 1077 return "YCbCr_420_SP_VENUS"; 1078 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS: 1079 return "YCrCb_420_SP_VENUS"; 1080 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC: 1081 return "YCbCr_420_SP_VENUS_UBWC"; 1082 default: 1083 return "Unknown pixel format"; 1084 } 1085} 1086 1087const char *HWCDisplay::GetDisplayString() { 1088 switch (type_) { 1089 case kPrimary: 1090 return "primary"; 1091 case kHDMI: 1092 return "hdmi"; 1093 case kVirtual: 1094 return "virtual"; 1095 default: 1096 return "invalid"; 1097 } 1098} 1099 1100int HWCDisplay::SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels) { 1101 if (x_pixels <= 0 || y_pixels <= 0) { 1102 DLOGV("Unsupported config: x_pixels=%d, y_pixels=%d", x_pixels, y_pixels); 1103 return -EINVAL; 1104 } 1105 1106 if (framebuffer_config_->x_pixels == x_pixels && framebuffer_config_->y_pixels == y_pixels) { 1107 return 0; 1108 } 1109 1110 DisplayConfigVariableInfo active_config; 1111 uint32_t active_config_index = 0; 1112 display_intf_->GetActiveConfig(&active_config_index); 1113 DisplayError error = display_intf_->GetConfig(active_config_index, &active_config); 1114 if (error != kErrorNone) { 1115 DLOGV("GetConfig variable info failed. Error = %d", error); 1116 return -EINVAL; 1117 } 1118 1119 if (active_config.x_pixels <= 0 || active_config.y_pixels <= 0) { 1120 DLOGV("Invalid panel resolution (%dx%d)", active_config.x_pixels, active_config.y_pixels); 1121 return -EINVAL; 1122 } 1123 1124 // Create rects to represent the new source and destination crops 1125 LayerRect crop = LayerRect(0, 0, FLOAT(x_pixels), FLOAT(y_pixels)); 1126 LayerRect dst = LayerRect(0, 0, FLOAT(active_config.x_pixels), FLOAT(active_config.y_pixels)); 1127 // Set rotate90 to false since this is taken care of during regular composition. 1128 bool rotate90 = false; 1129 error = display_intf_->IsScalingValid(crop, dst, rotate90); 1130 if (error != kErrorNone) { 1131 DLOGV("Unsupported resolution: (%dx%d)", x_pixels, y_pixels); 1132 return -EINVAL; 1133 } 1134 1135 framebuffer_config_->x_pixels = x_pixels; 1136 framebuffer_config_->y_pixels = y_pixels; 1137 framebuffer_config_->vsync_period_ns = active_config.vsync_period_ns; 1138 framebuffer_config_->x_dpi = active_config.x_dpi; 1139 framebuffer_config_->y_dpi = active_config.y_dpi; 1140 1141 DLOGI("New framebuffer resolution (%dx%d)", framebuffer_config_->x_pixels, 1142 framebuffer_config_->y_pixels); 1143 1144 return 0; 1145} 1146 1147void HWCDisplay::GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels) { 1148 *x_pixels = framebuffer_config_->x_pixels; 1149 *y_pixels = framebuffer_config_->y_pixels; 1150} 1151 1152void HWCDisplay::ScaleDisplayFrame(hwc_rect_t *display_frame) { 1153 if (!IsFrameBufferScaled()) { 1154 return; 1155 } 1156 1157 uint32_t active_config_index = 0; 1158 display_intf_->GetActiveConfig(&active_config_index); 1159 DisplayConfigVariableInfo active_config; 1160 DisplayError error = display_intf_->GetConfig(active_config_index, &active_config); 1161 if (error != kErrorNone) { 1162 DLOGE("GetConfig variable info failed. Error = %d", error); 1163 return; 1164 } 1165 1166 float custom_x_pixels = FLOAT(framebuffer_config_->x_pixels); 1167 float custom_y_pixels = FLOAT(framebuffer_config_->y_pixels); 1168 float active_x_pixels = FLOAT(active_config.x_pixels); 1169 float active_y_pixels = FLOAT(active_config.y_pixels); 1170 float x_pixels_ratio = active_x_pixels / custom_x_pixels; 1171 float y_pixels_ratio = active_y_pixels / custom_y_pixels; 1172 float layer_width = FLOAT(display_frame->right - display_frame->left); 1173 float layer_height = FLOAT(display_frame->bottom - display_frame->top); 1174 1175 display_frame->left = INT(x_pixels_ratio * FLOAT(display_frame->left)); 1176 display_frame->top = INT(y_pixels_ratio * FLOAT(display_frame->top)); 1177 display_frame->right = INT(FLOAT(display_frame->left) + layer_width * x_pixels_ratio); 1178 display_frame->bottom = INT(FLOAT(display_frame->top) + layer_height * y_pixels_ratio); 1179} 1180 1181bool HWCDisplay::IsFrameBufferScaled() { 1182 if (framebuffer_config_->x_pixels == 0 || framebuffer_config_->y_pixels == 0) { 1183 return false; 1184 } 1185 uint32_t panel_x_pixels = 0; 1186 uint32_t panel_y_pixels = 0; 1187 GetPanelResolution(&panel_x_pixels, &panel_y_pixels); 1188 return (framebuffer_config_->x_pixels != panel_x_pixels) || 1189 (framebuffer_config_->y_pixels != panel_y_pixels); 1190} 1191 1192void HWCDisplay::GetPanelResolution(uint32_t *x_pixels, uint32_t *y_pixels) { 1193 DisplayConfigVariableInfo active_config; 1194 uint32_t active_config_index = 0; 1195 display_intf_->GetActiveConfig(&active_config_index); 1196 DisplayError error = display_intf_->GetConfig(active_config_index, &active_config); 1197 if (error != kErrorNone) { 1198 DLOGE("GetConfig variable info failed. Error = %d", error); 1199 return; 1200 } 1201 *x_pixels = active_config.x_pixels; 1202 *y_pixels = active_config.y_pixels; 1203} 1204 1205int HWCDisplay::SetDisplayStatus(uint32_t display_status) { 1206 int status = 0; 1207 const hwc_procs_t *hwc_procs = *hwc_procs_; 1208 1209 switch (display_status) { 1210 case kDisplayStatusResume: 1211 display_paused_ = false; 1212 case kDisplayStatusOnline: 1213 status = SetPowerMode(HWC_POWER_MODE_NORMAL); 1214 break; 1215 case kDisplayStatusPause: 1216 display_paused_ = true; 1217 case kDisplayStatusOffline: 1218 status = SetPowerMode(HWC_POWER_MODE_OFF); 1219 break; 1220 default: 1221 DLOGW("Invalid display status %d", display_status); 1222 return -EINVAL; 1223 } 1224 1225 if (display_status == kDisplayStatusResume || 1226 display_status == kDisplayStatusPause) { 1227 hwc_procs->invalidate(hwc_procs); 1228 } 1229 1230 return status; 1231} 1232 1233int HWCDisplay::SetCursorPosition(int x, int y) { 1234 DisplayError error = kErrorNone; 1235 1236 if (shutdown_pending_) { 1237 return 0; 1238 } 1239 1240 error = display_intf_->SetCursorPosition(x, y); 1241 if (error != kErrorNone) { 1242 if (error == kErrorShutDown) { 1243 shutdown_pending_ = true; 1244 return 0; 1245 } 1246 DLOGE("Failed for x = %d y = %d, Error = %d", x, y, error); 1247 return -1; 1248 } 1249 1250 return 0; 1251} 1252 1253int HWCDisplay::OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) { 1254 DisplayError error = display_intf_->OnMinHdcpEncryptionLevelChange(min_enc_level); 1255 if (error != kErrorNone) { 1256 DLOGE("Failed. Error = %d", error); 1257 return -1; 1258 } 1259 1260 return 0; 1261} 1262 1263void HWCDisplay::MarkLayersForGPUBypass(hwc_display_contents_1_t *content_list) { 1264 for (size_t i = 0 ; i < (content_list->numHwLayers - 1); i++) { 1265 hwc_layer_1_t *layer = &content_list->hwLayers[i]; 1266 layer->compositionType = HWC_OVERLAY; 1267 } 1268} 1269 1270uint32_t HWCDisplay::RoundToStandardFPS(uint32_t fps) { 1271 static const uint32_t standard_fps[4] = {30, 24, 48, 60}; 1272 1273 int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0])); 1274 for (int i = 0; i < count; i++) { 1275 if ((standard_fps[i] - fps) < 2) { 1276 // Most likely used for video, the fps can fluctuate 1277 // Ex: b/w 29 and 30 for 30 fps clip 1278 return standard_fps[i]; 1279 } 1280 } 1281 1282 return fps; 1283} 1284 1285void HWCDisplay::ApplyScanAdjustment(hwc_rect_t *display_frame) { 1286} 1287 1288DisplayError HWCDisplay::SetCSC(ColorSpace_t source, LayerCSC *target) { 1289 switch (source) { 1290 case ITU_R_601: *target = kCSCLimitedRange601; break; 1291 case ITU_R_601_FR: *target = kCSCFullRange601; break; 1292 case ITU_R_709: *target = kCSCLimitedRange709; break; 1293 default: 1294 DLOGE("Unsupported CSC: %d", source); 1295 return kErrorNotSupported; 1296 } 1297 1298 return kErrorNone; 1299} 1300 1301DisplayError HWCDisplay::SetIGC(IGC_t source, LayerIGC *target) { 1302 switch (source) { 1303 case IGC_NotSpecified: *target = kIGCNotSpecified; break; 1304 case IGC_sRGB: *target = kIGCsRGB; break; 1305 default: 1306 DLOGE("Unsupported IGC: %d", source); 1307 return kErrorNotSupported; 1308 } 1309 1310 return kErrorNone; 1311} 1312 1313DisplayError HWCDisplay::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) { 1314 const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata); 1315 LayerBuffer *layer_buffer = layer->input_buffer; 1316 1317 if (!meta_data) { 1318 return kErrorNone; 1319 } 1320 1321 if (meta_data->operation & UPDATE_COLOR_SPACE) { 1322 if (SetCSC(meta_data->colorSpace, &layer->csc) != kErrorNone) { 1323 return kErrorNotSupported; 1324 } 1325 } 1326 1327 if (meta_data->operation & SET_IGC) { 1328 if (SetIGC(meta_data->igc, &layer->igc) != kErrorNone) { 1329 return kErrorNotSupported; 1330 } 1331 } 1332 1333 if (meta_data->operation & UPDATE_REFRESH_RATE) { 1334 layer->frame_rate = RoundToStandardFPS(meta_data->refreshrate); 1335 } 1336 1337 if ((meta_data->operation & PP_PARAM_INTERLACED) && meta_data->interlaced) { 1338 layer_buffer->flags.interlace = true; 1339 } 1340 1341 if (meta_data->operation & LINEAR_FORMAT) { 1342 layer_buffer->format = GetSDMFormat(meta_data->linearFormat, 0); 1343 } 1344 1345 if (meta_data->operation & UPDATE_BUFFER_GEOMETRY) { 1346 int actual_width = pvt_handle->width; 1347 int actual_height = pvt_handle->height; 1348 AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(pvt_handle, actual_width, actual_height); 1349 layer_buffer->width = actual_width; 1350 layer_buffer->height = actual_height; 1351 } 1352 1353 if (meta_data->operation & SET_SINGLE_BUFFER_MODE) { 1354 layer->flags.single_buffer = meta_data->isSingleBufferMode; 1355 // Graphics can set this operation on all types of layers including FB and set the actual value 1356 // to 0. To protect against SET operations of 0 value, we need to do a logical OR. 1357 layer_stack_.flags.single_buffered_layer_present |= meta_data->isSingleBufferMode; 1358 } 1359 1360 if (meta_data->operation & S3D_FORMAT) { 1361 std::map<int, LayerBufferS3DFormat>::iterator it = 1362 s3d_format_hwc_to_sdm_.find(meta_data->s3dFormat); 1363 if (it != s3d_format_hwc_to_sdm_.end()) { 1364 layer->input_buffer->s3d_format = it->second; 1365 } else { 1366 DLOGW("Invalid S3D format %d", meta_data->s3dFormat); 1367 } 1368 } 1369 1370 return kErrorNone; 1371} 1372 1373int HWCDisplay::SetPanelBrightness(int level) { 1374 int ret = 0; 1375 if (display_intf_) 1376 ret = display_intf_->SetPanelBrightness(level); 1377 else 1378 ret = -EINVAL; 1379 1380 return ret; 1381} 1382 1383int HWCDisplay::GetPanelBrightness(int *level) { 1384 return display_intf_->GetPanelBrightness(level); 1385} 1386 1387int HWCDisplay::ToggleScreenUpdates(bool enable) { 1388 const hwc_procs_t *hwc_procs = *hwc_procs_; 1389 display_paused_ = enable ? false : true; 1390 hwc_procs->invalidate(hwc_procs); 1391 return 0; 1392} 1393 1394int HWCDisplay::ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload, 1395 PPDisplayAPIPayload *out_payload, 1396 PPPendingParams *pending_action) { 1397 int ret = 0; 1398 1399 if (display_intf_) 1400 ret = display_intf_->ColorSVCRequestRoute(in_payload, out_payload, pending_action); 1401 else 1402 ret = -EINVAL; 1403 1404 return ret; 1405} 1406 1407int HWCDisplay::GetVisibleDisplayRect(hwc_rect_t* visible_rect) { 1408 if (!IsValid(display_rect_)) { 1409 return -EINVAL; 1410 } 1411 1412 visible_rect->left = INT(display_rect_.left); 1413 visible_rect->top = INT(display_rect_.top); 1414 visible_rect->right = INT(display_rect_.right); 1415 visible_rect->bottom = INT(display_rect_.bottom); 1416 DLOGI("Dpy = %d Visible Display Rect(%d %d %d %d)", visible_rect->left, visible_rect->top, 1417 visible_rect->right, visible_rect->bottom); 1418 1419 return 0; 1420} 1421 1422void HWCDisplay::ResetLayerCacheStack() { 1423 uint32_t layer_count = layer_stack_cache_.layer_count; 1424 for (uint32_t i = 0; i < layer_count; i++) { 1425 layer_stack_cache_.layer_cache[i] = LayerCache(); 1426 } 1427 layer_stack_cache_.layer_count = 0; 1428 layer_stack_cache_.animating = false; 1429 layer_stack_cache_.in_use = false; 1430} 1431 1432void HWCDisplay::SetSecureDisplay(bool secure_display_active) { 1433 secure_display_active_ = secure_display_active; 1434 return; 1435} 1436 1437int HWCDisplay::SetActiveDisplayConfig(int config) { 1438 return display_intf_->SetActiveConfig(config) == kErrorNone ? 0 : -1; 1439} 1440 1441int HWCDisplay::GetActiveDisplayConfig(uint32_t *config) { 1442 return display_intf_->GetActiveConfig(config) == kErrorNone ? 0 : -1; 1443} 1444 1445int HWCDisplay::GetDisplayConfigCount(uint32_t *count) { 1446 return display_intf_->GetNumVariableInfoConfigs(count) == kErrorNone ? 0 : -1; 1447} 1448 1449int HWCDisplay::GetDisplayAttributesForConfig(int config, DisplayConfigVariableInfo *attributes) { 1450 return display_intf_->GetConfig(config, attributes) == kErrorNone ? 0 : -1; 1451} 1452 1453bool HWCDisplay::SingleLayerUpdating(uint32_t app_layer_count) { 1454 uint32_t updating_count = 0; 1455 1456 for (uint i = 0; i < app_layer_count; i++) { 1457 Layer &layer = layer_stack_.layers[i]; 1458 if (layer.flags.updating) { 1459 updating_count++; 1460 } 1461 } 1462 1463 return (updating_count == 1); 1464} 1465 1466uint32_t HWCDisplay::SanitizeRefreshRate(uint32_t req_refresh_rate) { 1467 uint32_t refresh_rate = req_refresh_rate; 1468 1469 if (refresh_rate < min_refresh_rate_) { 1470 // Pick the next multiple of request which is within the range 1471 refresh_rate = (((min_refresh_rate_ / refresh_rate) + 1472 ((min_refresh_rate_ % refresh_rate) ? 1 : 0)) * refresh_rate); 1473 } 1474 1475 if (refresh_rate > max_refresh_rate_) { 1476 refresh_rate = max_refresh_rate_; 1477 } 1478 1479 return refresh_rate; 1480} 1481 1482} // namespace sdm 1483