1 /* 2 // Copyright(c)2014 IntelCorporation 3 // 4 // LicensedundertheApacheLicense,Version2.0(the"License"); 5 // youmaynotusethisfileexceptincompliancewiththeLicense. 6 // YoumayobtainacopyoftheLicenseat 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unlessrequiredbyapplicablelaworagreedtoinwriting,software 11 // distributedundertheLicenseisdistributedonan"ASIS"BASIS, 12 // WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied. 13 // SeetheLicenseforthespecificlanguagegoverningpermissionsand 14 // limitationsundertheLicense. 15 */ 16 #include <common/utils/HwcTrace.h> 17 #include <common/base/Drm.h> 18 #include <common/base/HwcLayerList.h> 19 #include <Hwcomposer.h> 20 #include <GraphicBuffer.h> 21 #include <IDisplayDevice.h> 22 #include <PlaneCapabilities.h> 23 #include <DisplayQuery.h> 24 #include <hal_public.h> 25 26 namespace android { 27 namespace intel { 28 29 HwcLayerList::HwcLayerList(hwc_display_contents_1_t *list, int disp) 30 : mList(list), 31 mLayerCount(0), 32 mLayers(), 33 mFBLayers(), 34 mSpriteCandidates(), 35 mOverlayCandidates(), 36 mZOrderConfig(), 37 mFrameBufferTarget(NULL), 38 mDisplayIndex(disp) 39 { 40 initialize(); 41 } 42 43 HwcLayerList::~HwcLayerList() 44 { 45 deinitialize(); 46 } 47 48 bool HwcLayerList::checkSupported(int planeType, HwcLayer *hwcLayer) 49 { 50 bool valid = false; 51 hwc_layer_1_t& layer = *(hwcLayer->getLayer()); 52 53 // if layer was forced to use FB 54 if (hwcLayer->getType() == HwcLayer::LAYER_FORCE_FB) { 55 VLOGTRACE("layer was forced to use HWC_FRAMEBUFFER"); 56 return false; 57 } 58 59 // check layer flags 60 if (layer.flags & HWC_SKIP_LAYER) { 61 VLOGTRACE("plane type %d: (skip layer flag was set)", planeType); 62 return false; 63 } 64 65 if (layer.handle == 0) { 66 WLOGTRACE("invalid buffer handle"); 67 return false; 68 } 69 70 // check usage 71 if (!(hwcLayer->getUsage() & GRALLOC_USAGE_HW_COMPOSER)) { 72 WLOGTRACE("not a composer layer"); 73 return false; 74 } 75 76 // check layer transform 77 valid = PlaneCapabilities::isTransformSupported(planeType, hwcLayer); 78 if (!valid) { 79 VLOGTRACE("plane type %d: (bad transform)", planeType); 80 return false; 81 } 82 83 // check buffer format 84 valid = PlaneCapabilities::isFormatSupported(planeType, hwcLayer); 85 if (!valid) { 86 VLOGTRACE("plane type %d: (bad buffer format)", planeType); 87 return false; 88 } 89 90 // check buffer size 91 valid = PlaneCapabilities::isSizeSupported(planeType, hwcLayer); 92 if (!valid) { 93 VLOGTRACE("plane type %d: (bad buffer size)", planeType); 94 return false; 95 } 96 97 // check layer blending 98 valid = PlaneCapabilities::isBlendingSupported(planeType, hwcLayer); 99 if (!valid) { 100 VLOGTRACE("plane type %d: (bad blending)", planeType); 101 return false; 102 } 103 104 // check layer scaling 105 valid = PlaneCapabilities::isScalingSupported(planeType, hwcLayer); 106 if (!valid) { 107 VLOGTRACE("plane type %d: (bad scaling)", planeType); 108 return false; 109 } 110 111 // TODO: check visible region? 112 return true; 113 } 114 115 bool HwcLayerList::checkRgbOverlaySupported(HwcLayer *hwcLayer) 116 { 117 hwc_layer_1_t& layer = *(hwcLayer->getLayer()); 118 119 // if layer was forced to use FB 120 if (hwcLayer->getType() == HwcLayer::LAYER_FORCE_FB) { 121 VLOGTRACE("layer was forced to use HWC_FRAMEBUFFER"); 122 return false; 123 } 124 125 // check layer flags 126 if (layer.flags & HWC_SKIP_LAYER) { 127 VLOGTRACE("skip layer flag was set"); 128 return false; 129 } 130 131 if (layer.handle == 0) { 132 WLOGTRACE("invalid buffer handle"); 133 return false; 134 } 135 136 // check usage 137 if (!(hwcLayer->getUsage() & GRALLOC_USAGE_HW_COMPOSER)) { 138 WLOGTRACE("not a composer layer"); 139 return false; 140 } 141 142 uint32_t format = hwcLayer->getFormat(); 143 if (format != HAL_PIXEL_FORMAT_BGRA_8888 && 144 format != HAL_PIXEL_FORMAT_BGRX_8888) { 145 return false; 146 } 147 148 const stride_t& stride = hwcLayer->getBufferStride(); 149 if (stride.rgb.stride > 4096) { 150 return false; 151 } 152 153 uint32_t blending = (uint32_t)hwcLayer->getLayer()->blending; 154 if (blending != HWC_BLENDING_NONE) { 155 return false; 156 } 157 158 uint32_t trans = hwcLayer->getLayer()->transform; 159 if (trans != 0) { 160 return false; 161 } 162 163 hwc_frect_t& src = hwcLayer->getLayer()->sourceCropf; 164 hwc_rect_t& dest = hwcLayer->getLayer()->displayFrame; 165 int srcW = (int)src.right - (int)src.left; 166 int srcH = (int)src.bottom - (int)src.top; 167 int dstW = dest.right - dest.left; 168 int dstH = dest.bottom - dest.top; 169 if (srcW != dstW || srcH != dstH) { 170 return false; 171 } 172 return true; 173 } 174 175 bool HwcLayerList::checkCursorSupported(HwcLayer *hwcLayer) 176 { 177 hwc_layer_1_t& layer = *(hwcLayer->getLayer()); 178 179 // if layer was forced to use FB 180 if (hwcLayer->getType() == HwcLayer::LAYER_FORCE_FB) { 181 VLOGTRACE("layer was forced to use HWC_FRAMEBUFFER"); 182 return false; 183 } 184 185 // check layer flags 186 if (layer.flags & HWC_SKIP_LAYER) { 187 VLOGTRACE("skip layer flag was set"); 188 return false; 189 } 190 191 if (!(layer.flags & HWC_IS_CURSOR_LAYER)) { 192 VLOGTRACE("not a cursor layer"); 193 return false; 194 } 195 196 if (hwcLayer->getIndex() != mLayerCount - 2) { 197 WLOGTRACE("cursor layer is not on top of zorder"); 198 return false; 199 } 200 201 if (layer.handle == 0) { 202 WLOGTRACE("invalid buffer handle"); 203 return false; 204 } 205 206 // check usage 207 if (!(hwcLayer->getUsage() & GRALLOC_USAGE_HW_COMPOSER)) { 208 WLOGTRACE("not a composer layer"); 209 return false; 210 } 211 212 uint32_t format = hwcLayer->getFormat(); 213 if (format != HAL_PIXEL_FORMAT_BGRA_8888 && 214 format != HAL_PIXEL_FORMAT_RGBA_8888) { 215 WLOGTRACE("unexpected color format %u for cursor", format); 216 return false; 217 } 218 219 uint32_t trans = hwcLayer->getLayer()->transform; 220 if (trans != 0) { 221 WLOGTRACE("unexpected transform %u for cursor", trans); 222 return false; 223 } 224 225 hwc_frect_t& src = hwcLayer->getLayer()->sourceCropf; 226 hwc_rect_t& dest = hwcLayer->getLayer()->displayFrame; 227 int srcW = (int)src.right - (int)src.left; 228 int srcH = (int)src.bottom - (int)src.top; 229 int dstW = dest.right - dest.left; 230 int dstH = dest.bottom - dest.top; 231 if (srcW != dstW || srcH != dstH) { 232 WLOGTRACE("unexpected scaling for cursor: %dx%d => %dx%d", 233 srcW, srcH, dstW, dstH); 234 //return false; 235 } 236 237 if (srcW > 256 || srcH > 256) { 238 WLOGTRACE("unexpected size %dx%d for cursor", srcW, srcH); 239 return false; 240 } 241 242 return true; 243 } 244 245 246 bool HwcLayerList::initialize() 247 { 248 if (!mList || mList->numHwLayers == 0) { 249 ELOGTRACE("invalid hwc list"); 250 return false; 251 } 252 253 mLayerCount = (int)mList->numHwLayers; 254 mLayers.setCapacity(mLayerCount); 255 mFBLayers.setCapacity(mLayerCount); 256 mSpriteCandidates.setCapacity(mLayerCount); 257 mOverlayCandidates.setCapacity(mLayerCount); 258 mCursorCandidates.setCapacity(mLayerCount); 259 mZOrderConfig.setCapacity(mLayerCount); 260 261 PriorityVector rgbOverlayLayers; 262 rgbOverlayLayers.setCapacity(mLayerCount); 263 264 for (int i = 0; i < mLayerCount; i++) { 265 hwc_layer_1_t *layer = &mList->hwLayers[i]; 266 if (!layer) { 267 DEINIT_AND_RETURN_FALSE("layer %d is null", i); 268 } 269 270 if ((layer->compositionType != HWC_FRAMEBUFFER_TARGET) && 271 (layer->compositionType != HWC_FORCE_FRAMEBUFFER) && 272 (layer->compositionType != HWC_SIDEBAND)) 273 layer->compositionType = HWC_FRAMEBUFFER; 274 275 HwcLayer *hwcLayer = new HwcLayer(i, layer); 276 if (!hwcLayer) { 277 DEINIT_AND_RETURN_FALSE("failed to allocate hwc layer %d", i); 278 } 279 280 if (layer->compositionType == HWC_FRAMEBUFFER_TARGET) { 281 hwcLayer->setType(HwcLayer::LAYER_FRAMEBUFFER_TARGET); 282 mFrameBufferTarget = hwcLayer; 283 } else if (layer->compositionType == HWC_OVERLAY){ 284 // skipped layer, filtered by Display Analyzer 285 hwcLayer->setType(HwcLayer::LAYER_SKIPPED); 286 } else if (layer->compositionType == HWC_FORCE_FRAMEBUFFER) { 287 layer->compositionType = HWC_FRAMEBUFFER; 288 hwcLayer->setType(HwcLayer::LAYER_FORCE_FB); 289 // add layer to FB layer list for zorder check during plane assignment 290 mFBLayers.add(hwcLayer); 291 } else if (layer->compositionType == HWC_FRAMEBUFFER) { 292 // by default use GPU composition 293 hwcLayer->setType(HwcLayer::LAYER_FB); 294 mFBLayers.add(hwcLayer); 295 if (!DisplayQuery::forceFbScaling(mDisplayIndex)) { 296 if (checkCursorSupported(hwcLayer)) { 297 mCursorCandidates.add(hwcLayer); 298 } else if (checkRgbOverlaySupported(hwcLayer)) { 299 rgbOverlayLayers.add(hwcLayer); 300 } else if (checkSupported(DisplayPlane::PLANE_SPRITE, hwcLayer)) { 301 mSpriteCandidates.add(hwcLayer); 302 } else if (checkSupported(DisplayPlane::PLANE_OVERLAY, hwcLayer)) { 303 mOverlayCandidates.add(hwcLayer); 304 } else { 305 // noncandidate layer 306 } 307 } else { 308 if (checkSupported(DisplayPlane::PLANE_SPRITE, hwcLayer) && 309 mLayerCount == 2) { 310 // if fb scaling, support only one RGB layer on HWC 311 mSpriteCandidates.add(hwcLayer); 312 } else if (checkSupported(DisplayPlane::PLANE_OVERLAY, hwcLayer)) { 313 mOverlayCandidates.add(hwcLayer); 314 } else { 315 // noncandidate layer 316 } 317 } 318 } else if (layer->compositionType == HWC_SIDEBAND){ 319 hwcLayer->setType(HwcLayer::LAYER_SIDEBAND); 320 } else { 321 DEINIT_AND_RETURN_FALSE("invalid composition type %d", layer->compositionType); 322 } 323 // add layer to layer list 324 mLayers.add(hwcLayer); 325 } 326 327 if (mFrameBufferTarget == NULL) { 328 ELOGTRACE("no frame buffer target?"); 329 return false; 330 } 331 332 // If has layer besides of FB_Target, but no FBLayers, skip plane allocation 333 // Note: There is case that SF passes down a layerlist with only FB_Target 334 // layer; we need to have this FB_Target to be flipped as well, otherwise it 335 // will have the buffer queue blocked. (The buffer hold by driver cannot be 336 // released if new buffers' flip is skipped). 337 if ((mFBLayers.size() == 0) && (mLayers.size() > 1)) { 338 VLOGTRACE("no FB layers, skip plane allocation"); 339 return true; 340 } 341 342 bool hasOverlay = mOverlayCandidates.size() != 0; 343 while (rgbOverlayLayers.size()) { 344 HwcLayer *hwcLayer = rgbOverlayLayers.top(); 345 if (hasOverlay) { 346 mSpriteCandidates.add(hwcLayer); 347 } else { 348 mOverlayCandidates.add(hwcLayer); 349 } 350 rgbOverlayLayers.removeItemsAt(0); 351 } 352 353 allocatePlanes(); 354 //dump(); 355 return true; 356 } 357 358 void HwcLayerList::deinitialize() 359 { 360 if (mLayerCount == 0) { 361 return; 362 } 363 364 DisplayPlaneManager *planeManager = Hwcomposer::getInstance().getPlaneManager(); 365 for (int i = 0; i < mLayerCount; i++) { 366 HwcLayer *hwcLayer = mLayers.itemAt(i); 367 if (hwcLayer) { 368 DisplayPlane *plane = hwcLayer->detachPlane(); 369 if (plane) { 370 planeManager->reclaimPlane(mDisplayIndex, *plane); 371 } 372 } 373 delete hwcLayer; 374 } 375 376 mLayers.clear(); 377 mFBLayers.clear(); 378 mOverlayCandidates.clear(); 379 mSpriteCandidates.clear(); 380 mCursorCandidates.clear(); 381 mZOrderConfig.clear(); 382 mFrameBufferTarget = NULL; 383 mLayerCount = 0; 384 } 385 386 387 bool HwcLayerList::allocatePlanes() 388 { 389 return assignCursorPlanes(); 390 } 391 392 bool HwcLayerList::assignCursorPlanes() 393 { 394 int cursorCandidates = (int)mCursorCandidates.size(); 395 if (cursorCandidates == 0) { 396 return assignOverlayPlanes(); 397 } 398 399 DisplayPlaneManager *planeManager = Hwcomposer::getInstance().getPlaneManager(); 400 int planeNumber = planeManager->getFreePlanes(mDisplayIndex, DisplayPlane::PLANE_CURSOR); 401 if (planeNumber == 0) { 402 DLOGTRACE("no cursor plane available. candidates %d", cursorCandidates); 403 return assignOverlayPlanes(); 404 } 405 406 if (planeNumber > cursorCandidates) { 407 // assuming all cursor planes have the same capabilities, just 408 // need up to number of candidates for plane assignment 409 planeNumber = cursorCandidates; 410 } 411 412 for (int i = planeNumber; i >= 0; i--) { 413 // assign as many cursor planes as possible 414 if (assignCursorPlanes(0, i)) { 415 return true; 416 } 417 if (mZOrderConfig.size() != 0) { 418 ELOGTRACE("ZOrder config is not cleaned up!"); 419 } 420 } 421 return false; 422 } 423 424 425 bool HwcLayerList::assignCursorPlanes(int index, int planeNumber) 426 { 427 // index indicates position in mCursorCandidates to start plane assignment 428 if (planeNumber == 0) { 429 return assignOverlayPlanes(); 430 } 431 432 int cursorCandidates = (int)mCursorCandidates.size(); 433 for (int i = index; i <= cursorCandidates - planeNumber; i++) { 434 ZOrderLayer *zlayer = addZOrderLayer(DisplayPlane::PLANE_CURSOR, mCursorCandidates[i]); 435 if (assignCursorPlanes(i + 1, planeNumber - 1)) { 436 return true; 437 } 438 removeZOrderLayer(zlayer); 439 } 440 return false; 441 } 442 443 bool HwcLayerList::assignOverlayPlanes() 444 { 445 int overlayCandidates = (int)mOverlayCandidates.size(); 446 if (overlayCandidates == 0) { 447 return assignSpritePlanes(); 448 } 449 450 DisplayPlaneManager *planeManager = Hwcomposer::getInstance().getPlaneManager(); 451 int planeNumber = planeManager->getFreePlanes(mDisplayIndex, DisplayPlane::PLANE_OVERLAY); 452 if (planeNumber == 0) { 453 DLOGTRACE("no overlay plane available. candidates %d", overlayCandidates); 454 return assignSpritePlanes(); 455 } 456 457 if (planeNumber > overlayCandidates) { 458 // assuming all overlay planes have the same capabilities, just 459 // need up to number of candidates for plane assignment 460 planeNumber = overlayCandidates; 461 } 462 463 for (int i = planeNumber; i >= 0; i--) { 464 // assign as many overlay planes as possible 465 if (assignOverlayPlanes(0, i)) { 466 return true; 467 } 468 if (mZOrderConfig.size() != 0) { 469 ELOGTRACE("ZOrder config is not cleaned up!"); 470 } 471 } 472 return false; 473 } 474 475 476 bool HwcLayerList::assignOverlayPlanes(int index, int planeNumber) 477 { 478 // index indicates position in mOverlayCandidates to start plane assignment 479 if (planeNumber == 0) { 480 return assignSpritePlanes(); 481 } 482 483 int overlayCandidates = (int)mOverlayCandidates.size(); 484 for (int i = index; i <= overlayCandidates - planeNumber; i++) { 485 ZOrderLayer *zlayer = addZOrderLayer(DisplayPlane::PLANE_OVERLAY, mOverlayCandidates[i]); 486 if (assignOverlayPlanes(i + 1, planeNumber - 1)) { 487 return true; 488 } 489 removeZOrderLayer(zlayer); 490 } 491 return false; 492 } 493 494 bool HwcLayerList::assignSpritePlanes() 495 { 496 int spriteCandidates = (int)mSpriteCandidates.size(); 497 if (spriteCandidates == 0) { 498 return assignPrimaryPlane(); 499 } 500 501 // number does not include primary plane 502 DisplayPlaneManager *planeManager = Hwcomposer::getInstance().getPlaneManager(); 503 int planeNumber = planeManager->getFreePlanes(mDisplayIndex, DisplayPlane::PLANE_SPRITE); 504 if (planeNumber == 0) { 505 VLOGTRACE("no sprite plane available, candidates %d", spriteCandidates); 506 return assignPrimaryPlane(); 507 } 508 509 if (planeNumber > spriteCandidates) { 510 // assuming all sprite planes have the same capabilities, just 511 // need up to number of candidates for plane assignment 512 planeNumber = spriteCandidates; 513 } 514 515 for (int i = planeNumber; i >= 0; i--) { 516 // assign as many sprite planes as possible 517 if (assignSpritePlanes(0, i)) { 518 return true; 519 } 520 521 if (mOverlayCandidates.size() == 0 && mZOrderConfig.size() != 0) { 522 ELOGTRACE("ZOrder config is not cleaned up!"); 523 } 524 } 525 return false; 526 } 527 528 529 bool HwcLayerList::assignSpritePlanes(int index, int planeNumber) 530 { 531 if (planeNumber == 0) { 532 return assignPrimaryPlane(); 533 } 534 535 int spriteCandidates = (int)mSpriteCandidates.size(); 536 for (int i = index; i <= spriteCandidates - planeNumber; i++) { 537 ZOrderLayer *zlayer = addZOrderLayer(DisplayPlane::PLANE_SPRITE, mSpriteCandidates[i]); 538 if (assignSpritePlanes(i + 1, planeNumber - 1)) { 539 return true; 540 } 541 removeZOrderLayer(zlayer); 542 } 543 return false; 544 } 545 546 bool HwcLayerList::assignPrimaryPlane() 547 { 548 // find a sprit layer that is not candidate but has lower priority than candidates. 549 HwcLayer *spriteLayer = NULL; 550 for (int i = (int)mSpriteCandidates.size() - 1; i >= 0; i--) { 551 if (mSpriteCandidates[i]->mPlaneCandidate) 552 break; 553 554 spriteLayer = mSpriteCandidates[i]; 555 } 556 557 int candidates = (int)mZOrderConfig.size(); 558 int layers = (int)mFBLayers.size(); 559 bool ok = false; 560 561 if (candidates == layers - 1 && spriteLayer != NULL) { 562 // primary plane is configured as sprite, all sprite candidates are offloaded to display planes 563 ok = assignPrimaryPlaneHelper(spriteLayer); 564 if (!ok) { 565 VLOGTRACE("failed to use primary as sprite plane"); 566 } 567 } else if (candidates == 0) { 568 // none assigned, use primary plane for frame buffer target and set zorder to 0 569 ok = assignPrimaryPlaneHelper(mFrameBufferTarget, 0); 570 if (!ok) { 571 ELOGTRACE("failed to compose all layers to primary plane, should never happen"); 572 } 573 } else if (candidates == layers) { 574 // all assigned, primary plane may be used during ZOrder config. 575 ok = attachPlanes(); 576 if (!ok) { 577 VLOGTRACE("failed to assign layers without primary"); 578 } 579 } else { 580 // check if the remaining planes can be composed to frame buffer target (FBT) 581 // look up a legitimate Z order position to place FBT. 582 for (int i = 0; i < layers && !ok; i++) { 583 if (mFBLayers[i]->mPlaneCandidate) { 584 continue; 585 } 586 if (useAsFrameBufferTarget(mFBLayers[i])) { 587 ok = assignPrimaryPlaneHelper(mFrameBufferTarget, mFBLayers[i]->getZOrder()); 588 if (!ok) { 589 VLOGTRACE("failed to use zorder %d for frame buffer target", 590 mFBLayers[i]->getZOrder()); 591 } 592 } 593 } 594 if (!ok) { 595 VLOGTRACE("no possible zorder for frame buffer target"); 596 } 597 598 } 599 return ok; 600 } 601 602 bool HwcLayerList::assignPrimaryPlaneHelper(HwcLayer *hwcLayer, int zorder) 603 { 604 int type = DisplayPlane::PLANE_PRIMARY; 605 606 ZOrderLayer *zlayer = addZOrderLayer(type, hwcLayer, zorder); 607 bool ok = attachPlanes(); 608 if (!ok) { 609 removeZOrderLayer(zlayer); 610 } 611 return ok; 612 } 613 614 bool HwcLayerList::attachPlanes() 615 { 616 DisplayPlaneManager *planeManager = Hwcomposer::getInstance().getPlaneManager(); 617 if (!planeManager->isValidZOrder(mDisplayIndex, mZOrderConfig)) { 618 VLOGTRACE("invalid z order, size of config %d", mZOrderConfig.size()); 619 return false; 620 } 621 622 if (!planeManager->assignPlanes(mDisplayIndex, mZOrderConfig)) { 623 WLOGTRACE("failed to assign planes"); 624 return false; 625 } 626 627 VLOGTRACE("============= plane assignment==================="); 628 for (int i = 0; i < (int)mZOrderConfig.size(); i++) { 629 ZOrderLayer *zlayer = mZOrderConfig.itemAt(i); 630 if (zlayer->plane == NULL || zlayer->hwcLayer == NULL) { 631 ELOGTRACE("invalid ZOrderLayer, should never happen!!"); 632 return false; 633 } 634 635 zlayer->plane->setZOrder(i); 636 637 if (zlayer->plane->getType() == DisplayPlane::PLANE_CURSOR) { 638 zlayer->hwcLayer->setType(HwcLayer::LAYER_CURSOR_OVERLAY); 639 mFBLayers.remove(zlayer->hwcLayer); 640 } else if (zlayer->hwcLayer != mFrameBufferTarget) { 641 zlayer->hwcLayer->setType(HwcLayer::LAYER_OVERLAY); 642 // update FB layers for smart composition 643 mFBLayers.remove(zlayer->hwcLayer); 644 } 645 646 zlayer->hwcLayer->attachPlane(zlayer->plane, mDisplayIndex); 647 648 VLOGTRACE("total %d, layer %d, type %d, index %d, zorder %d", 649 mLayerCount - 1, 650 zlayer->hwcLayer->getIndex(), 651 zlayer->plane->getType(), 652 zlayer->plane->getIndex(), 653 zlayer->zorder); 654 655 delete zlayer; 656 } 657 658 mZOrderConfig.clear(); 659 return true; 660 } 661 662 bool HwcLayerList::useAsFrameBufferTarget(HwcLayer *target) 663 { 664 // check if zorder of target can be used as zorder of frame buffer target 665 // eligible only when all noncandidate layers can be merged to the target layer: 666 // 1) noncandidate layer and candidate layer below the target layer can't overlap 667 // if candidate layer is on top of non candidate layer, as "noncandidate layer" needs 668 // to be moved up to target layer in z order; 669 // 2) noncandidate layer and candidate layers above the target layer can't overlap 670 // if candidate layer is below noncandidate layer, as "noncandidate layer" needs 671 // to be moved down to target layer in z order. 672 673 int targetLayerIndex = target->getIndex(); 674 675 // check candidate and noncandidate layers below this candidate does not overlap 676 for (int below = 0; below < targetLayerIndex; below++) { 677 if (mFBLayers[below]->mPlaneCandidate) { 678 continue; 679 } else { 680 // check candidate layer above this noncandidate layer does not overlap 681 for (int above = below + 1; above < targetLayerIndex; above++) { 682 if (mFBLayers[above]->mPlaneCandidate == false) { 683 continue; 684 } 685 if (hasIntersection(mFBLayers[above], mFBLayers[below])) { 686 return false; 687 } 688 } 689 } 690 } 691 692 // check candidate and noncandidate layers above this candidate does not overlap 693 for (unsigned int above = targetLayerIndex + 1; above < mFBLayers.size(); above++) { 694 if (mFBLayers[above]->mPlaneCandidate) { 695 continue; 696 } else { 697 // check candidate layer below this noncandidate layer does not overlap 698 for (unsigned int below = targetLayerIndex + 1; below < above; below++) { 699 if (mFBLayers[below]->mPlaneCandidate == false) { 700 continue; 701 } 702 if (hasIntersection(mFBLayers[above], mFBLayers[below])) { 703 return false; 704 } 705 } 706 } 707 } 708 709 return true; 710 } 711 712 bool HwcLayerList::hasIntersection(HwcLayer *la, HwcLayer *lb) 713 { 714 hwc_layer_1_t *a = la->getLayer(); 715 hwc_layer_1_t *b = lb->getLayer(); 716 hwc_rect_t *aRect = &a->displayFrame; 717 hwc_rect_t *bRect = &b->displayFrame; 718 719 if (bRect->right <= aRect->left || 720 bRect->left >= aRect->right || 721 bRect->top >= aRect->bottom || 722 bRect->bottom <= aRect->top) 723 return false; 724 725 return true; 726 } 727 728 ZOrderLayer* HwcLayerList::addZOrderLayer(int type, HwcLayer *hwcLayer, int zorder) 729 { 730 ZOrderLayer *layer = new ZOrderLayer; 731 layer->planeType = type; 732 layer->hwcLayer = hwcLayer; 733 layer->zorder = (zorder != -1) ? zorder : hwcLayer->getZOrder(); 734 layer->plane = NULL; 735 736 if (hwcLayer->mPlaneCandidate) { 737 ELOGTRACE("plane is candidate!, order = %d", zorder); 738 } 739 740 hwcLayer->mPlaneCandidate = true; 741 742 if ((int)mZOrderConfig.indexOf(layer) >= 0) { 743 ELOGTRACE("layer exists!"); 744 } 745 746 mZOrderConfig.add(layer); 747 return layer; 748 } 749 750 void HwcLayerList::removeZOrderLayer(ZOrderLayer *layer) 751 { 752 if ((int)mZOrderConfig.indexOf(layer) < 0) { 753 ELOGTRACE("layer does not exist!"); 754 } 755 756 mZOrderConfig.remove(layer); 757 758 if (layer->hwcLayer->mPlaneCandidate == false) { 759 ELOGTRACE("plane is not candidate!, order %d", layer->zorder); 760 } 761 layer->hwcLayer->mPlaneCandidate = false; 762 delete layer; 763 } 764 765 void HwcLayerList::setupSmartComposition() 766 { 767 uint32_t compositionType = HWC_OVERLAY; 768 HwcLayer *hwcLayer = NULL; 769 770 // setup smart composition only there's no update on all FB layers 771 for (size_t i = 0; i < mFBLayers.size(); i++) { 772 hwcLayer = mFBLayers.itemAt(i); 773 if (hwcLayer->isUpdated()) { 774 compositionType = HWC_FRAMEBUFFER; 775 } 776 } 777 778 VLOGTRACE("smart composition enabled %s", 779 (compositionType == HWC_OVERLAY) ? "TRUE" : "FALSE"); 780 for (size_t i = 0; i < mFBLayers.size(); i++) { 781 hwcLayer = mFBLayers.itemAt(i); 782 switch (hwcLayer->getType()) { 783 case HwcLayer::LAYER_FB: 784 case HwcLayer::LAYER_FORCE_FB: 785 hwcLayer->setCompositionType(compositionType); 786 break; 787 default: 788 ELOGTRACE("Invalid layer type %d", hwcLayer->getType()); 789 break; 790 } 791 } 792 } 793 794 void HwcLayerList::updateFBT(hwc_display_contents_1_t *list) { 795 mFrameBufferTarget->update(&list->hwLayers[mLayerCount - 1]); 796 } 797 798 #if 1 // support overlay fallback to GLES 799 800 bool HwcLayerList::update(hwc_display_contents_1_t *list) 801 { 802 // basic check to make sure the consistance 803 if (!list) { 804 ELOGTRACE("null layer list"); 805 return false; 806 } 807 808 if ((int)list->numHwLayers != mLayerCount) { 809 ELOGTRACE("layer count doesn't match (%d, %d)", list->numHwLayers, mLayerCount); 810 return false; 811 } 812 813 // update list 814 mList = list; 815 816 bool ok = true; 817 // update all layers, call each layer's update() 818 for (int i = 0; i < mLayerCount; i++) { 819 HwcLayer *hwcLayer = mLayers.itemAt(i); 820 if (!hwcLayer) { 821 ELOGTRACE("no HWC layer for layer %d", i); 822 continue; 823 } 824 825 if (!hwcLayer->update(&list->hwLayers[i])) { 826 ok = false; 827 hwcLayer->setCompositionType(HWC_FORCE_FRAMEBUFFER); 828 } 829 } 830 831 if (!ok) { 832 ILOGTRACE("overlay fallback to GLES. flags: %#x", list->flags); 833 for (int i = 0; i < mLayerCount - 1; i++) { 834 HwcLayer *hwcLayer = mLayers.itemAt(i); 835 if (hwcLayer->getPlane() && 836 (hwcLayer->getCompositionType() == HWC_OVERLAY || 837 hwcLayer->getCompositionType() == HWC_CURSOR_OVERLAY)) { 838 hwcLayer->setCompositionType(HWC_FRAMEBUFFER); 839 } 840 } 841 mLayers.itemAt(mLayerCount - 1)->setCompositionType(HWC_FRAMEBUFFER_TARGET); 842 deinitialize(); 843 mList = list; 844 initialize(); 845 846 // update all layers again after plane re-allocation 847 for (int i = 0; i < mLayerCount; i++) { 848 HwcLayer *hwcLayer = mLayers.itemAt(i); 849 if (!hwcLayer) { 850 ELOGTRACE("no HWC layer for layer %d", i); 851 continue; 852 } 853 854 if (!hwcLayer->update(&list->hwLayers[i])) { 855 DLOGTRACE("fallback to GLES update failed on layer[%d]!\n", i); 856 } 857 } 858 } 859 860 setupSmartComposition(); 861 return true; 862 } 863 864 #else 865 866 bool HwcLayerList::update(hwc_display_contents_1_t *list) 867 { 868 bool ret; 869 870 // basic check to make sure the consistance 871 if (!list) { 872 ELOGTRACE("null layer list"); 873 return false; 874 } 875 876 if ((int)list->numHwLayers != mLayerCount) { 877 ELOGTRACE("layer count doesn't match (%d, %d)", list->numHwLayers, mLayerCount); 878 return false; 879 } 880 881 // update list 882 mList = list; 883 884 // update all layers, call each layer's update() 885 for (int i = 0; i < mLayerCount; i++) { 886 HwcLayer *hwcLayer = mLayers.itemAt(i); 887 if (!hwcLayer) { 888 ELOGTRACE("no HWC layer for layer %d", i); 889 continue; 890 } 891 892 hwcLayer->update(&list->hwLayers[i]); 893 } 894 895 setupSmartComposition(); 896 return true; 897 } 898 899 #endif 900 901 DisplayPlane* HwcLayerList::getPlane(uint32_t index) const 902 { 903 HwcLayer *hwcLayer; 904 905 if (index >= mLayers.size()) { 906 ELOGTRACE("invalid layer index %d", index); 907 return 0; 908 } 909 910 hwcLayer = mLayers.itemAt(index); 911 if ((hwcLayer->getType() == HwcLayer::LAYER_FB) || 912 (hwcLayer->getType() == HwcLayer::LAYER_FORCE_FB) || 913 (hwcLayer->getType() == HwcLayer::LAYER_SKIPPED)) { 914 return 0; 915 } 916 917 if (hwcLayer->getHandle() == 0) { 918 DLOGTRACE("plane is attached with invalid handle"); 919 return 0; 920 } 921 922 return hwcLayer->getPlane(); 923 } 924 925 void HwcLayerList::postFlip() 926 { 927 for (size_t i = 0; i < mLayers.size(); i++) { 928 HwcLayer *hwcLayer = mLayers.itemAt(i); 929 hwcLayer->postFlip(); 930 } 931 } 932 933 void HwcLayerList::dump(Dump& d) 934 { 935 d.append("Layer list: (number of layers %d):\n", mLayers.size()); 936 d.append(" LAYER | TYPE | PLANE | INDEX | Z Order \n"); 937 d.append("-------+------------------------+----------------------------\n"); 938 for (size_t i = 0; i < mLayers.size(); i++) { 939 HwcLayer *hwcLayer = mLayers.itemAt(i); 940 DisplayPlane *plane; 941 int planeIndex = -1; 942 int zorder = -1; 943 const char *type = "HWC_FB"; 944 const char *planeType = "N/A"; 945 946 if (hwcLayer) { 947 switch (hwcLayer->getType()) { 948 case HwcLayer::LAYER_FB: 949 case HwcLayer::LAYER_FORCE_FB: 950 type = "HWC_FB"; 951 break; 952 case HwcLayer::LAYER_OVERLAY: 953 case HwcLayer::LAYER_SKIPPED: 954 type = "HWC_OVERLAY"; 955 break; 956 case HwcLayer::LAYER_FRAMEBUFFER_TARGET: 957 type = "HWC_FRAMEBUFFER_TARGET"; 958 break; 959 case HwcLayer::LAYER_SIDEBAND: 960 type = "HWC_SIDEBAND"; 961 break; 962 case HwcLayer::LAYER_CURSOR_OVERLAY: 963 type = "HWC_CURSOR_OVERLAY"; 964 break; 965 default: 966 type = "Unknown"; 967 } 968 969 plane = hwcLayer->getPlane(); 970 if (plane) { 971 planeIndex = plane->getIndex(); 972 zorder = plane->getZOrder(); 973 switch (plane->getType()) { 974 case DisplayPlane::PLANE_OVERLAY: 975 planeType = "OVERLAY"; 976 break; 977 case DisplayPlane::PLANE_SPRITE: 978 planeType = "SPRITE"; 979 break; 980 case DisplayPlane::PLANE_PRIMARY: 981 planeType = "PRIMARY"; 982 break; 983 case DisplayPlane::PLANE_CURSOR: 984 planeType = "CURSOR"; 985 break; 986 default: 987 planeType = "Unknown"; 988 } 989 } 990 991 d.append(" %2d | %22s | %8s | %3D | %3D \n", 992 i, type, planeType, planeIndex, zorder); 993 } 994 } 995 } 996 997 998 void HwcLayerList::dump() 999 { 1000 static char const* compositionTypeName[] = { 1001 "GLES", 1002 "HWC", 1003 "BG", 1004 "FBT", 1005 "SB", 1006 "CUR", 1007 "N/A"}; 1008 1009 static char const* planeTypeName[] = { 1010 "SPRITE", 1011 "OVERLAY", 1012 "PRIMARY", 1013 "CURSOR", 1014 "UNKNOWN"}; 1015 1016 DLOGTRACE(" numHwLayers = %u, flags = %08x", mList->numHwLayers, mList->flags); 1017 1018 DLOGTRACE(" type | handle | hints | flags | tr | blend | alpha | format | source crop | frame | index | zorder | plane "); 1019 DLOGTRACE("------+----------+-------+-------+----+-------+-------+----------+-----------------------------------+---------------------------+-------+--------+---------"); 1020 1021 1022 for (int i = 0 ; i < mLayerCount ; i++) { 1023 const hwc_layer_1_t&l = mList->hwLayers[i]; 1024 DisplayPlane *plane = mLayers[i]->getPlane(); 1025 int planeIndex = -1; 1026 int zorder = -1; 1027 const char *planeType = "N/A"; 1028 if (plane) { 1029 planeIndex = plane->getIndex(); 1030 zorder = plane->getZOrder(); 1031 planeType = planeTypeName[plane->getType()]; 1032 } 1033 1034 DLOGTRACE( 1035 " %4s | %8x | %5x | %5x | %2x | %5x | %5x | %8x | [%7.1f,%7.1f,%7.1f,%7.1f] | [%5d,%5d,%5d,%5d] | %5d | %6d | %7s ", 1036 compositionTypeName[l.compositionType], 1037 mLayers[i]->getHandle(), l.hints, l.flags, l.transform, l.blending, l.planeAlpha, mLayers[i]->getFormat(), 1038 l.sourceCropf.left, l.sourceCropf.top, l.sourceCropf.right, l.sourceCropf.bottom, 1039 l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom, 1040 planeIndex, zorder, planeType); 1041 } 1042 1043 } 1044 1045 1046 } // namespace intel 1047 } // namespace android 1048
