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