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