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