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