HwcLayerList.cpp revision 198b6a9e530c98c4c56d373302ba06e3861fdd6a
1/* 2 * Copyright © 2012 Intel Corporation 3 * All rights reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 22 * IN THE SOFTWARE. 23 * 24 * Authors: 25 * Jackie Li <yaodong.li@intel.com> 26 * 27 */ 28#include <HwcTrace.h> 29#include <Drm.h> 30#include <HwcLayerList.h> 31#include <Hwcomposer.h> 32#include <GraphicBuffer.h> 33#include <IDisplayDevice.h> 34#include <PlaneCapabilities.h> 35#include <DisplayQuery.h> 36 37namespace android { 38namespace intel { 39 40inline bool operator==(const hwc_rect_t& x, const hwc_rect_t& y) 41{ 42 return (x.top == y.top && 43 x.bottom == y.bottom && 44 x.left == y.left && 45 x.right == y.right); 46} 47 48inline bool operator !=(const hwc_rect_t& x, const hwc_rect_t& y) 49{ 50 return !operator==(x, y); 51} 52 53inline bool operator ==(const hwc_frect_t& x, const hwc_frect_t& y) 54{ 55 return (x.top == y.top && 56 x.bottom == y.bottom && 57 x.left == y.left && 58 x.right == y.right); 59} 60 61inline bool operator !=(const hwc_frect_t& x, const hwc_frect_t& y) 62{ 63 return !operator==(x, y); 64} 65 66HwcLayer::HwcLayer(int index, hwc_layer_1_t *layer) 67 : mIndex(index), 68 mLayer(layer), 69 mPlane(0), 70 mFormat(DataBuffer::FORMAT_INVALID), 71 mWidth(0), 72 mHeight(0), 73 mUsage(0), 74 mHandle(0), 75 mIsProtected(false), 76 mType(LAYER_FB), 77 mPriority(0), 78 mTransform(0), 79 mUpdated(false) 80{ 81 memset(&mSourceCropf, 0, sizeof(mSourceCropf)); 82 memset(&mDisplayFrame, 0, sizeof(mDisplayFrame)); 83 memset(&mStride, 0, sizeof(mStride)); 84 85 setupAttributes(); 86} 87 88HwcLayer::~HwcLayer() 89{ 90 if (mPlane) { 91 WTRACE("HwcLayer is not cleaned up"); 92 } 93 94 mLayer = NULL; 95 mPlane = NULL; 96} 97 98bool HwcLayer::attachPlane(DisplayPlane* plane, int device) 99{ 100 if (mPlane) { 101 ETRACE("failed to attach plane, plane exists"); 102 return false; 103 } 104 105 if (!plane) { 106 ETRACE("Invalid plane"); 107 return false; 108 } 109 110 // update plane's z order 111 // z order = layer's index + 1 112 // reserve z order 0 for frame buffer target layer 113 plane->setZOrder(mIndex + 1); 114 plane->assignToDevice(device); 115 mPlane = plane; 116 return true; 117} 118 119DisplayPlane* HwcLayer::detachPlane() 120{ 121 // reset plane's z order 122 if (mPlane) 123 mPlane->setZOrder(-1); 124 DisplayPlane *plane = mPlane; 125 mPlane = 0; 126 return plane; 127} 128 129void HwcLayer::setType(uint32_t type) 130{ 131 if (!mLayer) 132 return; 133 134 switch (type) { 135 case LAYER_OVERLAY: 136 case LAYER_SKIPPED: 137 mLayer->compositionType = HWC_OVERLAY; 138 mLayer->hints |= HWC_HINT_CLEAR_FB; 139 break; 140 // NOTE: set compositionType to HWC_FRAMEBUFFER here so that we have 141 // a chance to submit the primary changes to HW. 142 // Upper layer HWComposer will reset the compositionType automatically. 143 case LAYER_FRAMEBUFFER_TARGET: 144 case LAYER_FB: 145 case LAYER_FORCE_FB: 146 default: 147 mLayer->compositionType = HWC_FRAMEBUFFER; 148 break; 149 } 150 151 mType = type; 152} 153 154uint32_t HwcLayer::getType() const 155{ 156 return mType; 157} 158 159void HwcLayer::setCompositionType(int32_t type) 160{ 161 mLayer->compositionType = type; 162} 163 164int32_t HwcLayer::getCompositionType() const 165{ 166 return mLayer->compositionType; 167} 168 169int HwcLayer::getIndex() const 170{ 171 return mIndex; 172} 173 174uint32_t HwcLayer::getFormat() const 175{ 176 return mFormat; 177} 178 179uint32_t HwcLayer::getBufferWidth() const 180{ 181 return mWidth; 182} 183 184uint32_t HwcLayer::getBufferHeight() const 185{ 186 return mHeight; 187} 188 189const stride_t& HwcLayer::getBufferStride() const 190{ 191 return mStride; 192} 193 194uint32_t HwcLayer::getUsage() const 195{ 196 return mUsage; 197} 198 199uint32_t HwcLayer::getHandle() const 200{ 201 return mHandle; 202} 203 204bool HwcLayer::isProtected() const 205{ 206 return mIsProtected; 207} 208 209hwc_layer_1_t* HwcLayer::getLayer() const 210{ 211 return mLayer; 212} 213 214DisplayPlane* HwcLayer::getPlane() const 215{ 216 return mPlane; 217} 218 219void HwcLayer::setPriority(uint32_t priority) 220{ 221 mPriority = priority; 222} 223 224uint32_t HwcLayer::getPriority() const 225{ 226 return mPriority; 227} 228 229bool HwcLayer::update(hwc_layer_1_t *layer) 230{ 231 // update layer 232 mLayer = layer; 233 setupAttributes(); 234 235 // if not a FB layer & a plane was attached update plane's data buffer 236 if (mPlane) { 237 mPlane->setPosition(layer->displayFrame.left, 238 layer->displayFrame.top, 239 layer->displayFrame.right - layer->displayFrame.left, 240 layer->displayFrame.bottom - layer->displayFrame.top); 241 mPlane->setSourceCrop(layer->sourceCropf.left, 242 layer->sourceCropf.top, 243 layer->sourceCropf.right - layer->sourceCropf.left, 244 layer->sourceCropf.bottom - layer->sourceCropf.top); 245 mPlane->setTransform(layer->transform); 246 bool ret = mPlane->setDataBuffer((uint32_t)layer->handle); 247 if (ret == true) { 248 return true; 249 } 250 WTRACE("failed to set data buffer, handle = %#x", (uint32_t)layer->handle); 251 if (!mIsProtected) { 252 // typical case: rotated buffer is not ready or handle is null 253 return false; 254 } else { 255 // protected video has to be rendered using overlay. 256 // if buffer is not ready overlay will still be attached to this layer 257 // but rendering needs to be skipped. 258 WTRACE("ignoring result of data buffer setting for protected video"); 259 return true; 260 } 261 } 262 263 return true; 264} 265 266bool HwcLayer::isUpdated() 267{ 268 return mUpdated; 269} 270 271void HwcLayer::postFlip() 272{ 273 mUpdated = false; 274 if (mPlane) { 275 mPlane->postFlip(); 276 } 277} 278 279void HwcLayer::setupAttributes() 280{ 281 if ((mLayer->flags & HWC_SKIP_LAYER) || 282 mTransform != mLayer->transform || 283 mSourceCropf != mLayer->sourceCropf || 284 mDisplayFrame != mLayer->displayFrame || 285 mHandle != (uint32_t)mLayer->handle || 286 DisplayQuery::isVideoFormat(mFormat)) { 287 // TODO: same handle does not mean there is always no update 288 mUpdated = true; 289 } 290 291 // update handle always as it can become "NULL" 292 // if the given layer is not ready 293 mTransform = mLayer->transform; 294 mSourceCropf = mLayer->sourceCropf; 295 mDisplayFrame = mLayer->displayFrame; 296 mHandle = (uint32_t)mLayer->handle; 297 298 if (mFormat != DataBuffer::FORMAT_INVALID) { 299 // other attributes have been set. 300 return; 301 } 302 303 if (mLayer->handle == NULL) { 304 VTRACE("invalid handle"); 305 return; 306 } 307 308 BufferManager *bm = Hwcomposer::getInstance().getBufferManager(); 309 if (bm == NULL) { 310 // TODO: this check is redundant 311 return; 312 } 313 314 DataBuffer *buffer = bm->lockDataBuffer((uint32_t)mLayer->handle); 315 if (!buffer) { 316 ETRACE("failed to get buffer"); 317 } else { 318 mFormat = buffer->getFormat(); 319 mWidth = buffer->getWidth(); 320 mHeight = buffer->getHeight(); 321 mStride = buffer->getStride(); 322 mPriority = (mSourceCropf.right - mSourceCropf.left) * (mSourceCropf.bottom - mSourceCropf.top); 323 mPriority <<= LAYER_PRIORITY_SIZE_OFFSET; 324 mPriority |= mIndex; 325 GraphicBuffer *gBuffer = (GraphicBuffer*)buffer; 326 mUsage = gBuffer->getUsage(); 327 mIsProtected = GraphicBuffer::isProtectedBuffer((GraphicBuffer*)buffer); 328 if (mIsProtected) { 329 mPriority |= LAYER_PRIORITY_PROTECTED; 330 } 331 bm->unlockDataBuffer(buffer); 332 } 333} 334 335//------------------------------------------------------------------------------ 336HwcLayerList::HwcLayerList(hwc_display_contents_1_t *list, 337 DisplayPlaneManager& dpm, 338 int disp) 339 : mList(list), 340 mLayerCount(0), 341 mLayers(), 342 mOverlayLayers(), 343 mFBLayers(), 344 mZOrderConfig(), 345 mDisplayPlaneManager(dpm), 346 mDisplayIndex(disp) 347{ 348 if (mList) { 349 VTRACE("layer count = %d", list->numHwLayers); 350 mLayers.setCapacity(list->numHwLayers); 351 mOverlayLayers.setCapacity(list->numHwLayers); 352 mSkippedLayers.setCapacity(list->numHwLayers); 353 mFBLayers.setCapacity(list->numHwLayers); 354 mCandidates.setCapacity(list->numHwLayers); 355 mSpriteCandidates.setCapacity(list->numHwLayers); 356 mOverlayCandidates.setCapacity(list->numHwLayers); 357 mPossiblePrimaryLayers.setCapacity(list->numHwLayers); 358 mLayerCount = list->numHwLayers; 359 // analyze list from the top layer 360 analyze(); 361 } 362} 363 364HwcLayerList::~HwcLayerList() 365{ 366 CTRACE(); 367} 368 369//------------------------------------------------------------------------------ 370 371HwcLayerList::HwcLayerVector::HwcLayerVector() 372{ 373 374} 375 376int HwcLayerList::HwcLayerVector::do_compare(const void* lhs, 377 const void* rhs) const 378{ 379 const HwcLayer* l = *(HwcLayer**)lhs; 380 const HwcLayer* r = *(HwcLayer**)rhs; 381 382 // sorted from index 0 to n 383 return l->getIndex() - r->getIndex(); 384} 385 386HwcLayerList::PriorityVector::PriorityVector() 387{ 388 389} 390 391int HwcLayerList::PriorityVector::do_compare(const void* lhs, 392 const void* rhs) const 393{ 394 const HwcLayer* l = *(HwcLayer**)lhs; 395 const HwcLayer* r = *(HwcLayer**)rhs; 396 397 return r->getPriority() - l->getPriority(); 398} 399 400//------------------------------------------------------------------------------ 401bool HwcLayerList::checkSupported(int planeType, HwcLayer *hwcLayer) 402{ 403 bool valid = false; 404 hwc_layer_1_t& layer = *(hwcLayer->getLayer()); 405 406 // if layer was forced to use FB 407 if (hwcLayer->getType() == HwcLayer::LAYER_FORCE_FB) { 408 VTRACE("layer was forced to use HWC_FRAMEBUFFER"); 409 return false; 410 } 411 412 // check layer flags 413 if (layer.flags & HWC_SKIP_LAYER) { 414 VTRACE("plane type %d: (skip layer flag was set)", planeType); 415 return false; 416 } 417 418 if (layer.handle == 0) { 419 WTRACE("invalid buffer handle"); 420 return false; 421 } 422 423 // check usage 424 if (!hwcLayer->getUsage() & GRALLOC_USAGE_HW_COMPOSER) { 425 WTRACE("not a composer layer"); 426 return false; 427 } 428 429 // check buffer format 430 valid = PlaneCapabilities::isFormatSupported(planeType, 431 hwcLayer->getFormat(), 432 layer.transform); 433 if (!valid) { 434 VTRACE("plane type %d: (bad buffer format)", planeType); 435 return false; 436 } 437 438 // check buffer size 439 valid = PlaneCapabilities::isSizeSupported(planeType, 440 hwcLayer->getFormat(), 441 hwcLayer->getBufferWidth(), 442 hwcLayer->getBufferHeight(), 443 hwcLayer->getBufferStride()); 444 if (!valid) { 445 VTRACE("plane type %d: (bad buffer size)", planeType); 446 return false; 447 } 448 449 // check layer blending 450 valid = PlaneCapabilities::isBlendingSupported(planeType, 451 (uint32_t)layer.blending); 452 if (!valid) { 453 VTRACE("plane type %d: (bad blending)", planeType); 454 return false; 455 } 456 457 // check layer scaling 458 valid = PlaneCapabilities::isScalingSupported(planeType, 459 layer.sourceCropf, 460 layer.displayFrame); 461 if (!valid) { 462 VTRACE("plane type %d: (bad scaling)", planeType); 463 return false; 464 } 465 466 // TODO: check visible region? 467 return true; 468} 469 470void HwcLayerList::analyze() 471{ 472 Hwcomposer& hwc = Hwcomposer::getInstance(); 473 Drm *drm = hwc.getDrm(); 474 DisplayPlane *plane; 475 476 if (!mList || mLayerCount == 0 || !drm) 477 return; 478 479 if (!initialize()) { 480 ETRACE("failed to initialize layer list"); 481 return; 482 } 483 484 // go through layer list from top to bottom 485 preProccess(); 486 487 // assign planes 488 assignPlanes(); 489 490 // revisit the plane assignments 491 revisit(); 492} 493 494bool HwcLayerList::initialize() 495{ 496 for (size_t i = 0; i < mLayerCount; i++) { 497 hwc_layer_1_t *layer = &mList->hwLayers[i]; 498 if (!layer) { 499 // unlikely happen 500 ETRACE("layer %d is null", i); 501 DEINIT_AND_RETURN_FALSE(); 502 } 503 504 HwcLayer *hwcLayer = new HwcLayer(i, layer); 505 if (!hwcLayer) { 506 ETRACE("failed to allocate hwc layer %d", i); 507 DEINIT_AND_RETURN_FALSE(); 508 } 509 510 // by default use GPU for rendering 511 if (layer->compositionType == HWC_FRAMEBUFFER_TARGET) { 512 hwcLayer->setType(HwcLayer::LAYER_FRAMEBUFFER_TARGET); 513 } else if (layer->compositionType == HWC_OVERLAY){ 514 hwcLayer->setType(HwcLayer::LAYER_OVERLAY); 515 } else { 516 hwcLayer->setType(HwcLayer::LAYER_FB); 517 } 518 519 // add layer to layer list 520 mLayers.add(hwcLayer); 521 } 522 523 return true; 524} 525 526void HwcLayerList::deinitialize() 527{ 528 // reclaim planes 529 for (size_t i = 0; i < mLayers.size(); i++) { 530 HwcLayer *hwcLayer = mLayers.itemAt(i); 531 if (hwcLayer) { 532 DisplayPlane *plane = hwcLayer->detachPlane(); 533 if (plane) 534 mDisplayPlaneManager.reclaimPlane(*plane); 535 } 536 // delete HWC layer 537 delete hwcLayer; 538 } 539 540 mLayers.clear(); 541 mOverlayLayers.clear(); 542 mSkippedLayers.clear(); 543 mFBLayers.clear(); 544 mCandidates.clear(); 545 mOverlayCandidates.clear(); 546 mSpriteCandidates.clear(); 547 mPossiblePrimaryLayers.clear(); 548} 549 550void HwcLayerList::preProccess() 551{ 552 Hwcomposer& hwc = Hwcomposer::getInstance(); 553 554 // go through layer list, settle down the candidate layers 555 int topLayerIndex = mLayers.size() - 2; 556 for (int i = topLayerIndex; i >= 0; i--) { 557 HwcLayer *hwcLayer = mLayers.itemAt(i); 558 hwc_layer_1_t *layer = hwcLayer->getLayer(); 559 560 if (layer->compositionType == HWC_OVERLAY) { 561 hwcLayer->setType(HwcLayer::LAYER_SKIPPED); 562 mSkippedLayers.add(hwcLayer); 563 continue; 564 } 565 566 // add layer to FB layer list anyways 567 mFBLayers.add(hwcLayer); 568 569 if (checkSupported(DisplayPlane::PLANE_SPRITE, hwcLayer)) { 570 // found a sprite candidate, add it to candidate & sprite 571 // candidate list 572 mCandidates.add(hwcLayer); 573 mSpriteCandidates.add(hwcLayer); 574 continue; 575 } 576 577 if (checkSupported(DisplayPlane::PLANE_OVERLAY, hwcLayer)) { 578 // video play back has 'special' cases, do more checks!!! 579 580 // use case #1: bypass overlay layers of primary device 581 // if in extend video mode 582 if (mDisplayIndex == IDisplayDevice::DEVICE_PRIMARY) { 583 // check if HWC is in video extended mode 584 if (DisplayQuery::isVideoFormat(hwcLayer->getFormat()) && 585 hwc.getDisplayAnalyzer()->checkVideoExtendedMode()) { 586 VTRACE("video is skipped in extended mode"); 587 // remove it from fb layer list first 588 mFBLayers.remove(hwcLayer); 589 // layer has been skipped 590 hwcLayer->setType(HwcLayer::LAYER_SKIPPED); 591 mSkippedLayers.add(hwcLayer); 592 continue; 593 } 594 } 595 596 // use case #2: overlay is not allowed at the moment, use 3D for it 597 if (!(hwc.getDisplayAnalyzer()->isOverlayAllowed())) { 598 ITRACE("overlay is not allowed"); 599 continue; 600 } 601 602 // found a overlay candidate, add it to candidate & overlay 603 // candidate list 604 mCandidates.add(hwcLayer); 605 mOverlayCandidates.add(hwcLayer); 606 continue; 607 } 608 } 609} 610 611void HwcLayerList::assignPlanes() 612{ 613 // assign overlay planes 614 for (size_t idx = 0; idx < mOverlayCandidates.size(); idx++) { 615 // break if no free overlay 616 if (!mDisplayPlaneManager.hasFreeOverlay()) { 617 VTRACE("no free overlay available"); 618 break; 619 } 620 621 // attach plane 622 HwcLayer *hwcLayer = mOverlayCandidates.itemAt(idx); 623 DisplayPlane *plane = mDisplayPlaneManager.getOverlayPlane(mDisplayIndex); 624 if (!plane) { 625 WTRACE("failed to get overlay plane for display %d", mDisplayIndex); 626 break; 627 } 628 if (!hwcLayer->attachPlane(plane, mDisplayIndex)) { 629 WTRACE("failed to attach plane"); 630 mDisplayPlaneManager.reclaimPlane(*plane); 631 continue; 632 } 633 634 mFBLayers.remove(hwcLayer); 635 hwcLayer->setType(HwcLayer::LAYER_OVERLAY); 636 mOverlayLayers.add(hwcLayer); 637 } 638 639 for (size_t idx = 0; idx < mSpriteCandidates.size(); idx++) { 640 // break if no free sprite 641 if (!mDisplayPlaneManager.hasFreeSprite()) { 642 VTRACE("no free sprite available"); 643 break; 644 } 645 646 HwcLayer *hwcLayer = mSpriteCandidates.itemAt(idx); 647 DisplayPlane *plane = mDisplayPlaneManager.getSpritePlane(); 648 if (!plane) { 649 ETRACE("sprite plane is null"); 650 break; 651 } 652 if (!plane->enable()) { 653 ETRACE("sprite plane is not ready"); 654 mDisplayPlaneManager.putPlane(*plane); 655 continue; 656 } 657 658 // attach plane to hwc layer 659 if (!hwcLayer->attachPlane(plane, mDisplayIndex)) { 660 WTRACE("failed to attach plane"); 661 mDisplayPlaneManager.reclaimPlane(*plane); 662 continue; 663 } 664 mFBLayers.remove(hwcLayer); 665 hwcLayer->setType(HwcLayer::LAYER_OVERLAY); 666 mOverlayLayers.add(hwcLayer); 667 } 668} 669 670void HwcLayerList::adjustAssignment() 671{ 672 // find the least priority layer that has been attached a plane 673 HwcLayer *target = 0; 674 for (int i = mCandidates.size() - 1; i >= 0; i--) { 675 HwcLayer *hwcLayer = mCandidates.itemAt(i); 676 if (hwcLayer->getPlane() && 677 hwcLayer->getType() == HwcLayer::LAYER_OVERLAY) { 678 target = hwcLayer; 679 break; 680 } 681 } 682 683 // it's impossible, print a warning message 684 if (!target) { 685 WTRACE("failed to find a HWC_OVERLAY layer"); 686 return; 687 } 688 689 // if found a least priority layer detach plane from it and try to attach 690 // the reclaimed plane to the same type layer which has lower priority than 691 // the old layer 692 693 // set the layer type to LAYER_FORCE_FB 694 target->setType(HwcLayer::LAYER_FORCE_FB); 695 // remove layer from overlay layer list 696 mOverlayLayers.remove(target); 697 // add layer to FB layer list 698 mFBLayers.add(target); 699 700 // detach plane from the targeted layer 701 DisplayPlane *plane = target->detachPlane(); 702 // try to find next candidate which we can attach the plane to it 703 HwcLayer *next = target; 704 ssize_t idx; 705 do { 706 // remove layer from candidates list 707 mCandidates.remove(next); 708 709 // remove layer from specific candidates list 710 switch (plane->getType()) { 711 case DisplayPlane::PLANE_OVERLAY: 712 idx = mOverlayCandidates.remove(next); 713 if (idx >= 0 && (size_t)idx < mOverlayCandidates.size()) { 714 next = mOverlayCandidates.itemAt(idx); 715 } else { 716 next = NULL; 717 } 718 break; 719 case DisplayPlane::PLANE_SPRITE: 720 case DisplayPlane::PLANE_PRIMARY: 721 idx = mSpriteCandidates.remove(next); 722 if (idx >= 0 && (size_t)idx < mSpriteCandidates.size()) { 723 next = mSpriteCandidates.itemAt(idx); 724 } else { 725 next = NULL; 726 } 727 break; 728 } 729 } while(next && !next->attachPlane(plane, mDisplayIndex)); 730 731 // if failed to get next candidate, reclaim this plane 732 if (!next) { 733 VTRACE("reclaimed plane type %d, index %d", 734 plane->getType(), plane->getIndex()); 735 mDisplayPlaneManager.reclaimPlane(*plane); 736 return; 737 } 738 739 mFBLayers.remove(next); 740 next->setType(HwcLayer::LAYER_OVERLAY); 741 mOverlayLayers.add(next); 742} 743 744void HwcLayerList::revisit() 745{ 746 bool ret = false; 747 748 do { 749 // detach primaryPlane 750 detachPrimary(); 751 752 // calculate possible primary layers 753 updatePossiblePrimaryLayers(); 754 755 // if failed to find target primary layers, adjust current assignment 756 if (mFBLayers.size() && !mPossiblePrimaryLayers.size() ) { 757 VTRACE("failed to find primary target layers"); 758 adjustAssignment(); 759 continue; 760 } 761 762 ret = updateZOrderConfig(); 763 //if failed to apply a z order configuration, fall back an overlay layer 764 if (!ret && mOverlayLayers.size()) { 765 VTRACE("failed to set zorder config, adjusting plane assigment..."); 766 adjustAssignment(); 767 continue; 768 } 769 } while (!ret); 770 771 // skip protected layers if we cannot find an appropriate solution to 772 // assign overlays. 773 // This could barely happen. however, if it happened we want make sure 774 // screen content is NOT messed up. 775 for (size_t i = 0; i < mLayers.size(); i++) { 776 HwcLayer *layer = mLayers.itemAt(i); 777 // set a layer to layer overlay and add it back to overlay layer list 778 if (layer->getType() != HwcLayer::LAYER_OVERLAY && 779 layer->isProtected()) { 780 WTRACE("skip protected layer %d", layer->getIndex()); 781 layer->setType(HwcLayer::LAYER_SKIPPED); 782 // move it from FB layer list to overlay layer list 783 mFBLayers.remove(layer); 784 mSkippedLayers.add(layer); 785 } 786 } 787} 788 789bool HwcLayerList::updateZOrderConfig() 790{ 791 // acquire primary plane of this display device 792 DisplayPlane *primaryPlane = 793 mDisplayPlaneManager.getPrimaryPlane(mDisplayIndex); 794 if (!primaryPlane) { 795 // if primary allocation is failed, it should be a fatal error 796 ETRACE("failed to get primary plane for display %d", mDisplayIndex); 797 return false; 798 } 799 800 if (!primaryPlane->enable()) { 801 ETRACE("failed to enable primary plane"); 802 return false; 803 } 804 805 // primary can be used as sprite, setup Z order directly 806 if (usePrimaryAsSprite(primaryPlane)) { 807 VTRACE("primary is used as sprite"); 808 return setupZOrderConfig(); 809 } 810 811 // attach primary to frame buffer target 812 if (!usePrimaryAsFramebufferTarget(primaryPlane)) { 813 VTRACE("primary is unused"); 814 mDisplayPlaneManager.reclaimPlane(*primaryPlane); 815 return setupZOrderConfig(); 816 } 817 818 int primaryZOrder = 0; 819 // if no possible primary layers, place it at bottom 820 if (!mPossiblePrimaryLayers.size()) { 821 primaryPlane->setZOrder(primaryZOrder); 822 return setupZOrderConfig(); 823 } 824 // try to find out a suitable layer to place primary plane 825 bool success = false; 826 while (mPossiblePrimaryLayers.size()) { 827 HwcLayer *primaryLayer = mPossiblePrimaryLayers.itemAt(0); 828 // need update primary plane zorder 829 primaryZOrder = primaryLayer->getIndex() + 1; 830 primaryPlane->setZOrder(primaryZOrder); 831 832 // try to set z order config, return if setup z order successfully 833 success = setupZOrderConfig(); 834 if (success) { 835 VTRACE("primary was attached to framebuffer target"); 836 break; 837 } 838 // remove this layer from possible primary layer list 839 mPossiblePrimaryLayers.remove(primaryLayer); 840 } 841 842 return success; 843} 844 845bool HwcLayerList::usePrimaryAsSprite(DisplayPlane *primaryPlane) 846{ 847 // only one FB layer left, it's possible to use primary as sprite 848 // if the assignment successes, we are done! update primary z order 849 // and attach primary plane to this layer. 850 if ((mFBLayers.size() == 1)) { 851 HwcLayer *layer = mFBLayers.itemAt(0); 852 if (checkSupported(DisplayPlane::PLANE_PRIMARY, layer)) { 853 VTRACE("primary check passed for primary layer"); 854 // attach primary to layer 855 if (!layer->attachPlane(primaryPlane, mDisplayIndex)) { 856 WTRACE("failed to attach plane"); 857 mDisplayPlaneManager.reclaimPlane(*primaryPlane); 858 return false; 859 } 860 // set the layer type to overlay 861 layer->setType(HwcLayer::LAYER_OVERLAY); 862 // remove layer from FB layer list 863 mFBLayers.remove(layer); 864 // add layer to overlay layers 865 mOverlayLayers.add(layer); 866 return true; 867 } 868 } 869 870 return false; 871} 872 873void HwcLayerList::detachPrimary() 874{ 875 HwcLayer *framebufferTarget = mLayers.itemAt(mLayers.size() - 1); 876 DisplayPlane *primaryPlane = framebufferTarget->getPlane(); 877 878 // if primary plane was attached to framebuffer target 879 // detach plane 880 if (primaryPlane) { 881 framebufferTarget->detachPlane(); 882 // reclaim primary plane 883 mDisplayPlaneManager.reclaimPlane(*primaryPlane); 884 return; 885 } 886 887 // if primary plane was attached to a normal layer 888 for (size_t i = 0; i < mLayers.size() - 1; i++) { 889 HwcLayer *hwcLayer = mLayers.itemAt(i); 890 DisplayPlane *plane = hwcLayer->getPlane(); 891 if (!plane) 892 continue; 893 if (plane->getType() == DisplayPlane::PLANE_PRIMARY) { 894 // detach plane 895 hwcLayer->detachPlane(); 896 // set layer type to FRAMEBUFFER 897 hwcLayer->setType(HwcLayer::LAYER_FB); 898 // remove it from overlay list 899 mOverlayLayers.remove(hwcLayer); 900 // add it to fb layer list 901 mFBLayers.add(hwcLayer); 902 // reclaim primary plane 903 mDisplayPlaneManager.reclaimPlane(*plane); 904 break; 905 } 906 } 907} 908 909void HwcLayerList::updatePossiblePrimaryLayers() 910{ 911 mPossiblePrimaryLayers.clear(); 912 913 // if no FB layers, clear vector 914 if (!mFBLayers.size()) { 915 return; 916 } 917 918 for (size_t i = 0; i < mFBLayers.size(); i++) { 919 HwcLayer *target = mFBLayers.itemAt(i); 920 if (mergeFBLayersToLayer(target, i)) { 921 mPossiblePrimaryLayers.add(target); 922 } 923 } 924} 925 926bool HwcLayerList::usePrimaryAsFramebufferTarget(DisplayPlane *primaryPlane) 927{ 928 // don't attach primary if 929 // 0) no fb layers 930 // 1) all overlay layers have been handled 931 // NOTE: still need attach primary plane if no fb layers and some layers 932 // were skipped, or primary plane would be shut down and we will have no 933 // chance to fetch FB data at this point and screen will FREEZE on the last 934 // frame. 935 if (!mFBLayers.size() && mOverlayLayers.size()) { 936 return false; 937 } 938 939 // attach primary to frame buffer target 940 HwcLayer *layer = mLayers.itemAt(mLayers.size() - 1); 941 942 // invalidate primary plane's data buffer cache 943 primaryPlane->invalidateBufferCache(); 944 // NOTE: calling setType again to trigger glClear() for 945 // other overlay layers 946 layer->setType(HwcLayer::LAYER_FRAMEBUFFER_TARGET); 947 // attach primary plane, it has to be successful 948 layer->attachPlane(primaryPlane, mDisplayIndex); 949 950 return true; 951} 952 953bool HwcLayerList::calculatePrimaryZOrder(int& zorder) 954{ 955 int primaryZOrder = -1; 956 957 // if no FB layers, move primary to the bottom 958 if (!mFBLayers.size()) { 959 primaryZOrder = 0; 960 return true; 961 } 962 963 for (size_t i = 0; i < mFBLayers.size(); i++) { 964 HwcLayer *target = mFBLayers.itemAt(i); 965 // if all other FB layers can be merged to target layer 966 // then it's fine to put primary plane here 967 if (mergeFBLayersToLayer(target, i)) { 968 primaryZOrder = (target->getIndex() + 1); 969 break; 970 } 971 } 972 973 zorder = primaryZOrder; 974 975 return (primaryZOrder != -1) ? true : false; 976} 977 978bool HwcLayerList::mergeFBLayersToLayer(HwcLayer *target, int idx) 979{ 980 // merge all below FB layers to the target layer 981 for (int i = 0; i < idx; i++) { 982 HwcLayer *below = mFBLayers.itemAt(i); 983 if (!mergeToLayer(target, below)) { 984 return false; 985 } 986 } 987 988 // merge all above FB layer to the target layer 989 for (size_t i = idx + 1; i < mFBLayers.size(); i++) { 990 HwcLayer *above = mFBLayers.itemAt(i); 991 if (!mergeToLayer(target, above)) { 992 return false; 993 } 994 } 995 996 return true; 997} 998 999bool HwcLayerList::mergeToLayer(HwcLayer* target, HwcLayer* layer) 1000{ 1001 int targetZOrder = target->getIndex(); 1002 int layerZOrder = layer->getIndex(); 1003 1004 if (targetZOrder == layerZOrder) { 1005 return true; 1006 } 1007 1008 if (targetZOrder < layerZOrder) { 1009 // layer is above target layer need check intersection with all 1010 // overlay layers below this layer 1011 for (int i = layerZOrder - 1; i > targetZOrder; i--) { 1012 HwcLayer *l = mLayers.itemAt(i); 1013 if (l->getPlane() && l->getType() == HwcLayer::LAYER_OVERLAY) { 1014 // check intersection 1015 if (hasIntersection(l, layer)) { 1016 return false; 1017 } 1018 } 1019 } 1020 } else { 1021 // layer is under target layer need check intersection with all 1022 // overlay layers above this layer 1023 for (int i = layerZOrder + 1; i < targetZOrder; i++) { 1024 HwcLayer *l = mLayers.itemAt(i); 1025 if (l->getPlane() && l->getType() == HwcLayer::LAYER_OVERLAY) { 1026 // check intersection 1027 if (hasIntersection(l, layer)) { 1028 return false; 1029 } 1030 } 1031 } 1032 } 1033 1034 return true; 1035} 1036 1037bool HwcLayerList::hasIntersection(HwcLayer *la, HwcLayer *lb) 1038{ 1039 hwc_layer_1_t *a = la->getLayer(); 1040 hwc_layer_1_t *b = lb->getLayer(); 1041 hwc_rect_t *aRect = &a->displayFrame; 1042 hwc_rect_t *bRect = &b->displayFrame; 1043 1044 if (bRect->right <= aRect->left || 1045 bRect->left >= aRect->right || 1046 bRect->top >= aRect->bottom || 1047 bRect->bottom <= aRect->top) 1048 return false; 1049 1050 return true; 1051} 1052 1053bool HwcLayerList::setupZOrderConfig() 1054{ 1055 ZOrderConfig zorderConfig; 1056 DisplayPlane *plane; 1057 HwcLayer *layer; 1058 1059 zorderConfig.setCapacity(mOverlayLayers.size() + 1); 1060 1061 // add all planes in overlay layer list 1062 for (size_t i = 0; i < mOverlayLayers.size(); i++) { 1063 layer = mOverlayLayers.itemAt(i); 1064 plane = layer->getPlane(); 1065 if (!plane) 1066 continue; 1067 zorderConfig.add(plane); 1068 } 1069 1070 // add primary plane if it had been assigned to frame buffer target 1071 layer = mLayers.itemAt(mLayers.size() - 1); 1072 plane = layer->getPlane(); 1073 if (plane) { 1074 zorderConfig.add(plane); 1075 } 1076 1077 return mDisplayPlaneManager.setZOrderConfig(zorderConfig); 1078} 1079 1080void HwcLayerList::setupSmartComposition() 1081{ 1082 uint32_t compositionType = HWC_OVERLAY; 1083 HwcLayer *hwcLayer = NULL; 1084 1085 // setup smart composition only there's no update on all FB layers 1086 for (size_t i = 0; i < mFBLayers.size(); i++) { 1087 hwcLayer = mFBLayers.itemAt(i); 1088 if (hwcLayer->isUpdated()) { 1089 compositionType = HWC_FRAMEBUFFER; 1090 } 1091 } 1092 1093 VTRACE("smart composition enabled %s", 1094 (compositionType == HWC_OVERLAY) ? "TRUE" : "FALSE"); 1095 for (size_t i = 0; i < mFBLayers.size(); i++) { 1096 hwcLayer = mFBLayers.itemAt(i); 1097 switch (hwcLayer->getType()) { 1098 case HwcLayer::LAYER_FB: 1099 case HwcLayer::LAYER_FORCE_FB: 1100 hwcLayer->setCompositionType(compositionType); 1101 break; 1102 default: 1103 ETRACE("Invalid layer type %d", hwcLayer->getType()); 1104 break; 1105 } 1106 } 1107} 1108 1109bool HwcLayerList::update(hwc_display_contents_1_t *list) 1110{ 1111 bool ret; 1112 bool again = false; 1113 1114 CTRACE(); 1115 1116 // basic check to make sure the consistance 1117 if (!list) { 1118 ETRACE("null layer list"); 1119 return false; 1120 } 1121 1122 if (list->numHwLayers != mLayerCount) { 1123 ETRACE("layer count doesn't match (%d, %d)", list->numHwLayers, mLayerCount); 1124 return false; 1125 } 1126 1127 // update list 1128 mList = list; 1129 1130 do { 1131 again = false; 1132 // update all layers, call each layer's update() 1133 for (size_t i = 0; i < mLayerCount; i++) { 1134 HwcLayer *hwcLayer = mLayers.itemAt(i); 1135 if (!hwcLayer) { 1136 ETRACE("no HWC layer for layer %d", i); 1137 continue; 1138 } 1139 1140 ret = hwcLayer->update(&list->hwLayers[i]); 1141 if (ret == false) { 1142 // layer update failed, fall back to ST and revisit all plane 1143 // assignment 1144 WTRACE("failed to update layer %d, count %d, type %d", 1145 i, mLayerCount, hwcLayer->getType()); 1146 // if type of layer is LAYER_FB, that layer must have been added to mFBLayers. 1147 if (hwcLayer->getType() != HwcLayer::LAYER_FB) { 1148 // set layer to FB layer 1149 hwcLayer->setType(HwcLayer::LAYER_FB); 1150 // remove layer from overlay layer list 1151 mOverlayLayers.remove(hwcLayer); 1152 // add layer to FB layer list 1153 mFBLayers.add(hwcLayer); 1154 // revisit the overlay assignment. 1155 revisit(); 1156 } 1157 } else if (hwcLayer->getPlane() && 1158 hwcLayer->getType() == HwcLayer::LAYER_FB) { 1159 // layer update success, if the layer was assigned a plane 1160 // switch back to overlay and revisit all plane assignment 1161 ITRACE("updated layer %d, switch back to overlay", i); 1162 // set layer to overlay layer 1163 hwcLayer->setType(HwcLayer::LAYER_OVERLAY); 1164 // remove layer from Fb layer list 1165 mFBLayers.remove(hwcLayer); 1166 // add layer to overlay layer list 1167 mOverlayLayers.add(hwcLayer); 1168 // revisit plane assignment 1169 revisit(); 1170 // need update again since we changed the plane assignment 1171 again = true; 1172 } 1173 } 1174 } while (again && mOverlayLayers.size()); 1175 1176 setupSmartComposition(); 1177 return true; 1178} 1179 1180DisplayPlane* HwcLayerList::getPlane(uint32_t index) const 1181{ 1182 HwcLayer *hwcLayer; 1183 1184 if (index >= mLayers.size()) { 1185 ETRACE("invalid layer index %d", index); 1186 return 0; 1187 } 1188 1189 hwcLayer = mLayers.itemAt(index); 1190 if (!hwcLayer || (hwcLayer->getType() == HwcLayer::LAYER_FB) || 1191 (hwcLayer->getType() == HwcLayer::LAYER_FORCE_FB)) 1192 return 0; 1193 1194 if (hwcLayer->getHandle() == 0) { 1195 WTRACE("plane is attached with invalid handle"); 1196 return 0; 1197 } 1198 1199 return hwcLayer->getPlane(); 1200} 1201 1202bool HwcLayerList::hasProtectedLayer() 1203{ 1204 for (size_t i = 0; i < mLayers.size(); i++) { 1205 HwcLayer *hwcLayer = mLayers.itemAt(i); 1206 if (hwcLayer && hwcLayer->isProtected()) { 1207 VTRACE("protected layer found, layer index is %d", i); 1208 return true; 1209 } 1210 } 1211 return false; 1212} 1213 1214bool HwcLayerList::hasVisibleLayer() 1215{ 1216 // excluding framebuffer target layer 1217 int count = (int)mLayers.size() - 1; 1218 if (count <= 0) { 1219 ITRACE("number of layer is %d, visible layer is 0", mLayers.size()); 1220 return false; 1221 } 1222 1223 // the last layer is always frambuffer target layer? 1224 for (size_t i = 0; i < mLayers.size() - 1; i++) { 1225 HwcLayer *hwcLayer = mLayers.itemAt(i); 1226 if (hwcLayer == NULL) { 1227 // TODO: remove this redundant check 1228 continue; 1229 } 1230 if (hwcLayer->getType() == HwcLayer::LAYER_OVERLAY && 1231 hwcLayer->getPlane() == NULL) { 1232 // layer is invisible 1233 count--; 1234 } 1235 } 1236 ITRACE("number of visible layers %d", count); 1237 return count != 0; 1238} 1239 1240void HwcLayerList::postFlip() 1241{ 1242 for (size_t i = 0; i < mLayers.size(); i++) { 1243 HwcLayer *hwcLayer = mLayers.itemAt(i); 1244 hwcLayer->postFlip(); 1245 } 1246} 1247 1248void HwcLayerList::dump(Dump& d) 1249{ 1250 d.append("Layer list: (number of layers %d):\n", mLayers.size()); 1251 d.append(" LAYER | TYPE | PLANE | INDEX | Z Order \n"); 1252 d.append("-------+------------------------+----------------------------\n"); 1253 for (size_t i = 0; i < mLayers.size(); i++) { 1254 HwcLayer *hwcLayer = mLayers.itemAt(i); 1255 DisplayPlane *plane; 1256 int planeIndex = -1; 1257 int zorder = -1; 1258 const char *type = "HWC_FB"; 1259 const char *planeType = "N/A"; 1260 1261 if (hwcLayer) { 1262 switch (hwcLayer->getType()) { 1263 case HwcLayer::LAYER_FB: 1264 case HwcLayer::LAYER_FORCE_FB: 1265 type = "HWC_FB"; 1266 break; 1267 case HwcLayer::LAYER_OVERLAY: 1268 case HwcLayer::LAYER_SKIPPED: 1269 type = "HWC_OVERLAY"; 1270 break; 1271 case HwcLayer::LAYER_FRAMEBUFFER_TARGET: 1272 type = "HWC_FRAMEBUFFER_TARGET"; 1273 break; 1274 default: 1275 type = "Unknown"; 1276 } 1277 1278 plane = hwcLayer->getPlane(); 1279 if (plane) { 1280 planeIndex = plane->getIndex(); 1281 zorder = plane->getZOrder(); 1282 switch (plane->getType()) { 1283 case DisplayPlane::PLANE_OVERLAY: 1284 planeType = "OVERLAY"; 1285 break; 1286 case DisplayPlane::PLANE_SPRITE: 1287 planeType = "SPRITE"; 1288 break; 1289 case DisplayPlane::PLANE_PRIMARY: 1290 planeType = "PRIMARY"; 1291 break; 1292 default: 1293 planeType = "Unknown"; 1294 } 1295 } 1296 1297 d.append(" %2d | %22s | %8s | %3D | %3D \n", 1298 i, type, planeType, planeIndex, zorder); 1299 } 1300 } 1301} 1302 1303} // namespace intel 1304} // namespace android 1305