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