android-9.0.0_r3/s

/*
// Copyright (c) 2014 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/

#include <HwcTrace.h>
#include <IDisplayDevice.h>
#include <DisplayQuery.h>
#include <BufferManager.h>
#include <DisplayPlaneManager.h>
#include <Hwcomposer.h>
#include <DisplayAnalyzer.h>
#include <cutils/properties.h>
#include <GraphicBuffer.h>
#include <ExternalDevice.h>
#include <VirtualDevice.h>

namespace android {
namespace intel {

DisplayAnalyzer::DisplayAnalyzer()
    : mInitialized(false),
      mVideoExtModeEnabled(true),
      mVideoExtModeEligible(false),
      mVideoExtModeActive(false),
      mBlankDevice(false),
      mOverlayAllowed(true),
      mActiveInputState(true),
      mIgnoreVideoSkipFlag(false),
      mProtectedVideoSession(false),
      mCachedNumDisplays(0),
      mCachedDisplays(0),
      mPendingEvents(),
      mEventMutex(),
      mEventHandledCondition()
{
}

DisplayAnalyzer::~DisplayAnalyzer()
{
}

bool DisplayAnalyzer::initialize()
{
    // by default video extended mode is enabled
    char prop[PROPERTY_VALUE_MAX];
    if (property_get("hwc.video.extmode.enable", prop, "1") > 0) {
        mVideoExtModeEnabled = atoi(prop) ? true : false;
    }
    mVideoExtModeEligible = false;
    mVideoExtModeActive = false;
    mBlankDevice = false;
    mOverlayAllowed = true;
    mActiveInputState = true;
    mIgnoreVideoSkipFlag = false;
    mProtectedVideoSession = false;
    mCachedNumDisplays = 0;
    mCachedDisplays = 0;
    mPendingEvents.clear();
    mVideoStateMap.clear();
    mInitialized = true;

    return true;
}

void DisplayAnalyzer::deinitialize()
{
    mPendingEvents.clear();
    mVideoStateMap.clear();
    mInitialized = false;
}

void DisplayAnalyzer::analyzeContents(
        size_t numDisplays, hwc_display_contents_1_t** displays)
{
    // cache and use them only in this context during analysis
    mCachedNumDisplays = numDisplays;
    mCachedDisplays = displays;

    handlePendingEvents();

    if (mVideoExtModeEnabled) {
        handleVideoExtMode();
    }

    if (mBlankDevice) {
        // this will make sure device is blanked after geometry changes.
        // blank event is only processed once
        blankSecondaryDevice();
    }
}

void DisplayAnalyzer::handleVideoExtMode()
{
    bool eligible = mVideoExtModeEligible;
    checkVideoExtMode();
    if (eligible == mVideoExtModeEligible) {
        if (mVideoExtModeActive) {
            // need to mark all layers
            setCompositionType(0, HWC_OVERLAY, false);
        }
        return;
    }

    if (mVideoExtModeEligible) {
        if (mActiveInputState) {
            VTRACE("input is active");
        } else {
            enterVideoExtMode();
        }
    } else {
        exitVideoExtMode();
    }
}

void DisplayAnalyzer::checkVideoExtMode()
{
    if (mVideoStateMap.size() != 1) {
        mVideoExtModeEligible = false;
        return;
    }

    Hwcomposer *hwc = &Hwcomposer::getInstance();

    ExternalDevice *eDev = static_cast<ExternalDevice *>(hwc->getDisplayDevice(IDisplayDevice::DEVICE_EXTERNAL));
    VirtualDevice  *vDev = static_cast<VirtualDevice  *>(hwc->getDisplayDevice(IDisplayDevice::DEVICE_VIRTUAL));

    if ((!eDev || !eDev->isConnected()) && (!vDev || !vDev->isFrameServerActive())) {
        mVideoExtModeEligible = false;
        return;
    }

    bool geometryChanged = false;
    int activeDisplays = 0;

    hwc_display_contents_1_t *content = NULL;
    for (int i = 0; i < (int)mCachedNumDisplays; i++) {
        content = mCachedDisplays[i];
        if (content == NULL) {
            continue;
        }
        activeDisplays++;
        if (content->flags & HWC_GEOMETRY_CHANGED) {
            geometryChanged = true;
        }
    }

    if (activeDisplays <= 1) {
        mVideoExtModeEligible = false;
        return;
    }

    // video state update event may come later than geometry change event.
    // in that case, video extended mode is not detected properly.
#if 0
    if (geometryChanged == false) {
        // use previous analysis result
        return;
    }
#endif
    // reset eligibility of video extended mode
    mVideoExtModeEligible = false;

    // check if there is video layer in the primary device
    content = mCachedDisplays[0];
    if (content == NULL) {
        return;
    }

    buffer_handle_t videoHandle = 0;
    bool videoLayerExist = false;
    bool videoFullScreenOnPrimary = false;
    bool isVideoLayerSkipped = false;

    // exclude the frame buffer target layer
    for (int j = 0; j < (int)content->numHwLayers - 1; j++) {
        videoLayerExist = isVideoLayer(content->hwLayers[j]);
        if (videoLayerExist) {
            if ((content->hwLayers[j].flags & HWC_SKIP_LAYER)) {
                isVideoLayerSkipped = true;
            }
            videoHandle = content->hwLayers[j].handle;
            videoFullScreenOnPrimary = isVideoFullScreen(0, content->hwLayers[j]);
            break;
        }
    }

    if (videoLayerExist == false) {
        // no video layer is found in the primary layer
        return;
    }

    // check whether video layer exists in external device or virtual device
    // TODO: video may exist in virtual device but no in external device or vice versa
    // TODO: multiple video layers are not addressed here
    for (int i = 1; i < (int)mCachedNumDisplays; i++) {
        content = mCachedDisplays[i];
        if (content == NULL) {
            continue;
        }

        // exclude the frame buffer target layer
        for (int j = 0; j < (int)content->numHwLayers - 1; j++) {
            if (content->hwLayers[j].handle == videoHandle) {
                isVideoLayerSkipped |= (content->hwLayers[j].flags & HWC_SKIP_LAYER);
                VTRACE("video layer exists in device %d", i);
                if (isVideoLayerSkipped || videoFullScreenOnPrimary){
                    VTRACE("Video ext mode eligible, %d, %d",
                            isVideoLayerSkipped, videoFullScreenOnPrimary);
                    mVideoExtModeEligible = true;
                } else {
                    mVideoExtModeEligible = isVideoFullScreen(i, content->hwLayers[j]);
                }
                return;
            }
        }
    }
}

bool DisplayAnalyzer::isVideoExtModeActive()
{
    return mVideoExtModeActive;
}

bool DisplayAnalyzer::isVideoExtModeEnabled()
{
#if 1
    // enable it for run-time debugging purpose.
    char prop[PROPERTY_VALUE_MAX];
    if (property_get("hwc.video.extmode.enable", prop, "1") > 0) {
        mVideoExtModeEnabled = atoi(prop) ? true : false;
    }
    ITRACE("video extended mode enabled: %d", mVideoExtModeEnabled);
#endif

    return mVideoExtModeEnabled;
}

bool DisplayAnalyzer::isVideoLayer(hwc_layer_1_t &layer)
{
    bool ret = false;
    BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
    if (!layer.handle) {
        return false;
    }
    DataBuffer *buffer = bm->lockDataBuffer(layer.handle);
     if (!buffer) {
         ETRACE("failed to get buffer");
     } else {
        ret = DisplayQuery::isVideoFormat(buffer->getFormat());
        bm->unlockDataBuffer(buffer);
    }
    return ret;
}

bool DisplayAnalyzer::isVideoFullScreen(int device, hwc_layer_1_t &layer)
{
    IDisplayDevice *displayDevice = Hwcomposer::getInstance().getDisplayDevice(device);
    if (!displayDevice) {
        return false;
    }
    int width = 0, height = 0;
    if (!displayDevice->getDisplaySize(&width, &height)) {
        return false;
    }

    VTRACE("video left %d, right %d, top %d, bottom %d, device width %d, height %d",
        layer.displayFrame.left, layer.displayFrame.right,
        layer.displayFrame.top, layer.displayFrame.bottom,
        width, height);

    // full-screen defintion:
    // width of target display frame == width of target device, with 1 pixel of tolerance, or
    // Height of target display frame == height of target device, with 1 pixel of tolerance, or
    // width * height of display frame > 90% of width * height of display device, or
    // any of above condition is met on either primary display or secondary display
    int dstW = layer.displayFrame.right - layer.displayFrame.left;
    int dstH = layer.displayFrame.bottom - layer.displayFrame.top;

    if (abs(dstW - width) > 1 &&
        abs(dstH - height) > 1 &&
        dstW * dstH * 10 < width * height * 9) {
        VTRACE("video is not full-screen");
        return false;
    }
    return true;
}

bool DisplayAnalyzer::isOverlayAllowed()
{
    return mOverlayAllowed;
}

int DisplayAnalyzer::getVideoInstances()
{
    return (int)mVideoStateMap.size();
}

void DisplayAnalyzer::postHotplugEvent(bool connected)
{
    if (!connected) {
        // enable vsync on the primary device immediately
        Hwcomposer::getInstance().getVsyncManager()->enableDynamicVsync(true);
    }

    // handle hotplug event (vsync switch) asynchronously
    Event e;
    e.type = HOTPLUG_EVENT;
    e.bValue = connected;
    postEvent(e);
    Hwcomposer::getInstance().invalidate();
}

void DisplayAnalyzer::postVideoEvent(int instanceID, int state)
{
    Event e;
    e.type = VIDEO_EVENT;
    e.videoEvent.instanceID = instanceID;
    e.videoEvent.state = state;
    postEvent(e);
    if ((state == VIDEO_PLAYBACK_STARTING) ||
        (state == VIDEO_PLAYBACK_STOPPING && mProtectedVideoSession)) {
        Hwcomposer::getInstance().invalidate();
        mOverlayAllowed = false;
        hwc_display_contents_1_t *content = NULL;
        for (int i = 0; i < (int)mCachedNumDisplays; i++) {
            setCompositionType(i, HWC_FRAMEBUFFER, true);
        }
        // wait for up to 100ms until overlay is disabled.
        int loop = 0;
        while (loop++ < 6) {
            if (Hwcomposer::getInstance().getPlaneManager()->isOverlayPlanesDisabled())
                break;
            usleep(16700);
        }
        if (loop >= 6) {
            WTRACE("timeout disabling overlay ");
        }
    }
}

void DisplayAnalyzer::postBlankEvent(bool blank)
{
    Event e;
    e.type = BLANK_EVENT;
    e.bValue = blank;
    postEvent(e);
    Hwcomposer::getInstance().invalidate();
}

void DisplayAnalyzer::postInputEvent(bool active)
{
    Event e;
    e.type = INPUT_EVENT;
    e.bValue = active;
    postEvent(e);
    Hwcomposer::getInstance().invalidate();
}

void DisplayAnalyzer::postIdleEntryEvent(void)
{
    Event e;
    e.type = IDLE_ENTRY_EVENT;
    e.nValue = 0;
    postEvent(e);
}

void DisplayAnalyzer::postEvent(Event& e)
{
    Mutex::Autolock lock(mEventMutex);
    mPendingEvents.add(e);
}

bool DisplayAnalyzer::getEvent(Event& e)
{
    Mutex::Autolock lock(mEventMutex);
    if (mPendingEvents.size() == 0) {
        return false;
    }
    e = mPendingEvents[0];
    mPendingEvents.removeAt(0);
    return true;
}

void DisplayAnalyzer::handlePendingEvents()
{
    // handle one event per analysis to avoid blocking surface flinger
    // some event may take lengthy time to process
    Event e;
    if (!getEvent(e)) {
        return;
    }

    switch (e.type) {
    case HOTPLUG_EVENT:
        handleHotplugEvent(e.bValue);
        break;
    case BLANK_EVENT:
        handleBlankEvent(e.bValue);
        break;
    case VIDEO_EVENT:
        handleVideoEvent(e.videoEvent.instanceID, e.videoEvent.state);
        break;
    case TIMING_EVENT:
        handleTimingEvent();
        break;
    case INPUT_EVENT:
        handleInputEvent(e.bValue);
        break;
    case DPMS_EVENT:
        handleDpmsEvent(e.nValue);
        break;
    case IDLE_ENTRY_EVENT:
        handleIdleEntryEvent(e.nValue);
        break;
    case IDLE_EXIT_EVENT:
        handleIdleExitEvent();
        break;
    case VIDEO_CHECK_EVENT:
        handleVideoCheckEvent();
        break;
    }
}

void DisplayAnalyzer::handleHotplugEvent(bool connected)
{
    Hwcomposer *hwc = &Hwcomposer::getInstance();
    if (connected) {
        if (mVideoStateMap.size() == 1) {
            // Some video apps wouldn't update video state again when plugin HDMI
            // and fail to reset refresh rate
            ExternalDevice *dev = NULL;
            dev = (ExternalDevice *)hwc->getDisplayDevice(IDisplayDevice::DEVICE_EXTERNAL);
            if (!dev || !dev->isConnected()) {
                ITRACE("External device isn't connected");
                return;
            }
            if (hwc->getMultiDisplayObserver()->isExternalDeviceTimingFixed()) {
                VTRACE("Timing of external device is fixed.");
                return;
            }
            VideoSourceInfo info;
            int instanceID = mVideoStateMap.keyAt(0);
            status_t err = hwc->getMultiDisplayObserver()->getVideoSourceInfo(
                    instanceID, &info);
            if (err == NO_ERROR) {
                int hz = dev->getRefreshRate();
                if (hz > 0 && info.frameRate > 0 && hz != info.frameRate) {
                    ITRACE("Old Hz %d, new one %d", hz, info.frameRate);
                    dev->setRefreshRate(info.frameRate);
                } else
                    WTRACE("Old Hz %d is invalid, %d", hz, info.frameRate);
            }
        }
    } else {
        if (mVideoStateMap.size() == 1) {
            // Reset input state if HDMI is plug out to
            // avoid entering extended mode immediately after HDMI is plug in
            mActiveInputState = true;
        }
    }
}

void DisplayAnalyzer::handleBlankEvent(bool blank)
{
    mBlankDevice = blank;
    // force geometry changed in the secondary device to reset layer composition type
    for (int i = 0; i < (int)mCachedNumDisplays; i++) {
        if (i == IDisplayDevice::DEVICE_PRIMARY) {
            continue;
        }
        if (mCachedDisplays[i]) {
            mCachedDisplays[i]->flags |= HWC_GEOMETRY_CHANGED;
        }
    }
    blankSecondaryDevice();
}

void DisplayAnalyzer::handleTimingEvent()
{
    // check whether external device is connected, reset refresh rate to match video frame rate
    // if video is in playing state or reset refresh rate to default preferred one if video is not
    // at playing state
    Hwcomposer *hwc = &Hwcomposer::getInstance();
    ExternalDevice *dev = NULL;
    dev = (ExternalDevice *)hwc->getDisplayDevice(IDisplayDevice::DEVICE_EXTERNAL);
    if (!dev) {
        return;
    }

    if (!dev->isConnected()) {
        return;
    }

    if (hwc->getMultiDisplayObserver()->isExternalDeviceTimingFixed()) {
        VTRACE("Timing of external device is fixed.");
        return;
    }

    int hz = 0;
    if (mVideoStateMap.size() == 1) {
        VideoSourceInfo info;
        int instanceID = mVideoStateMap.keyAt(0);
        status_t err = hwc->getMultiDisplayObserver()->getVideoSourceInfo(
                instanceID, &info);
        if (err == NO_ERROR) {
            hz = info.frameRate;
        }
    }

    dev->setRefreshRate(hz);
}

void DisplayAnalyzer::handleVideoEvent(int instanceID, int state)
{
    mVideoStateMap.removeItem(instanceID);
    if (state != VIDEO_PLAYBACK_STOPPED) {
        mVideoStateMap.add(instanceID, state);
    }

    Hwcomposer *hwc = &Hwcomposer::getInstance();

    // sanity check
    if (hwc->getMultiDisplayObserver()->getVideoSessionNumber() !=
        (int)mVideoStateMap.size()) {
        WTRACE("session number does not match!!");
        mVideoStateMap.clear();
        if (state != VIDEO_PLAYBACK_STOPPED) {
            mVideoStateMap.add(instanceID, state);
        }
    }

    // check if composition type needs to be reset
    bool reset = false;
    if ((state == VIDEO_PLAYBACK_STARTING) ||
        (state == VIDEO_PLAYBACK_STOPPING && mProtectedVideoSession)) {
        // if video is in starting or stopping stage, overlay use is temporarily not allowed to
        // avoid scrambed RGB overlay if video is protected.
        mOverlayAllowed = false;
        reset = true;
    } else {
        reset = !mOverlayAllowed;
        mOverlayAllowed = true;
    }

    if (reset) {
        hwc_display_contents_1_t *content = NULL;
        for (int i = 0; i < (int)mCachedNumDisplays; i++) {
            setCompositionType(i, HWC_FRAMEBUFFER, true);
        }
    }

    if (mVideoStateMap.size() == 0) {
        // reset active input state after video playback stops.
        // MDS should update input state in 5 seconds after video playback starts
        mActiveInputState = true;
    }

    mProtectedVideoSession = false;
    if (state == VIDEO_PLAYBACK_STARTED) {
        VideoSourceInfo info;
        hwc->getMultiDisplayObserver()->getVideoSourceInfo(
                getFirstVideoInstanceSessionID(), &info);
        mProtectedVideoSession = info.isProtected;
    }
    // Setting timing immediately,
    // Don't posthone to next circle
    handleTimingEvent();

    handleVideoCheckEvent();
}

void DisplayAnalyzer::blankSecondaryDevice()
{
    hwc_display_contents_1_t *content = NULL;
    hwc_layer_1 *layer = NULL;
    for (int i = 0; i < (int)mCachedNumDisplays; i++) {
        if (i == IDisplayDevice::DEVICE_PRIMARY) {
            continue;
        }
        content = mCachedDisplays[i];
        if (content == NULL) {
            continue;
        }

        for (int j = 0; j < (int)content->numHwLayers - 1; j++) {
            layer = &content->hwLayers[j];
            if (!layer) {
                continue;
            }
            if (mBlankDevice) {
                layer->hints |= HWC_HINT_CLEAR_FB;
                layer->flags &= ~HWC_SKIP_LAYER;
                layer->compositionType = HWC_OVERLAY;
            } else {
                layer->hints &= ~HWC_HINT_CLEAR_FB;
                layer->compositionType = HWC_FRAMEBUFFER;
            }
        }
    }
}

void DisplayAnalyzer::handleInputEvent(bool active)
{
    if (active == mActiveInputState) {
        WTRACE("same input state: %d", active);
    }
    mActiveInputState = active;
    if (!mVideoExtModeEligible) {
        ITRACE("not eligible for video extended mode");
        return;
    }

    if (active) {
        exitVideoExtMode();
    } else {
        enterVideoExtMode();
    }
}

void DisplayAnalyzer::handleDpmsEvent(int delayCount)
{
    if (mActiveInputState || !mVideoExtModeEligible) {
        ITRACE("aborting display power off in video extended mode");
        return;
    }

    if (delayCount < DELAY_BEFORE_DPMS_OFF) {
        Event e;
        e.type = DPMS_EVENT;
        e.nValue = delayCount + 1;
        postEvent(e);
        Hwcomposer::getInstance().invalidate();
        return;
    }

    if (Hwcomposer::getInstance().getVsyncManager()->getVsyncSource() ==
        IDisplayDevice::DEVICE_PRIMARY) {
            Hwcomposer::getInstance().getDrm()->setDpmsMode(
            IDisplayDevice::DEVICE_PRIMARY,
                IDisplayDevice::DEVICE_DISPLAY_STANDBY);
        ETRACE("primary display is source of vsync, we only dim backlight");
        return;
    }

    // panel can't be powered off as touch panel shares the power supply with LCD.
    DTRACE("primary display coupled with touch on Saltbay, only dim backlight");
    Hwcomposer::getInstance().getDrm()->setDpmsMode(
               IDisplayDevice::DEVICE_PRIMARY,
               IDisplayDevice::DEVICE_DISPLAY_STANDBY);
               //IDisplayDevice::DEVICE_DISPLAY_OFF);
    return;
}


void DisplayAnalyzer::handleIdleEntryEvent(int count)
{
    DTRACE("handling idle entry event, count %d", count);
    if (hasProtectedLayer()) {
        ITRACE("Ignoring idle entry as protected layer exists.");
        setCompositionType(0, HWC_FRAMEBUFFER, true);
        return;
    }

    // stop idle entry if external device is connected
    if (mCachedDisplays && mCachedDisplays[IDisplayDevice::DEVICE_EXTERNAL]) {
        ITRACE("Ignoring idle entry as external device is connected.");
        setCompositionType(0, HWC_FRAMEBUFFER, true);
        return;
    }

    // stop idle entry if video playback is active
    // TODO: remove this check for Annidale
    if (mVideoStateMap.size() > 0) {
        ITRACE("Ignoring idle entry as video session is active.");
        setCompositionType(0, HWC_FRAMEBUFFER, true);
        return;
    }

    setCompositionType(0, HWC_FORCE_FRAMEBUFFER, true);

    // next prepare/set will exit idle state.
    Event e;
    e.type = IDLE_EXIT_EVENT;
    postEvent(e);
}

void DisplayAnalyzer::handleIdleExitEvent()
{
    DTRACE("handling idle exit event");

    setCompositionType(0, HWC_FRAMEBUFFER, true);
}

void DisplayAnalyzer::handleVideoCheckEvent()
{
    // check if the first seen video layer on secondary device (HDMI/WFD) is marked as skipped
    // it is assumed video is always skipped if the first seen video layer is skipped
    // this is to workaround secure video layer transmitted over non secure output
    // and HWC_SKIP_LAYER set during rotation animation.
    mIgnoreVideoSkipFlag = false;

    if (mVideoStateMap.size() != 1 ||
        mCachedNumDisplays <= 1) {
        return;
    }

    intptr_t videoHandles[mCachedNumDisplays];
    for (int i = 0; i < (int)mCachedNumDisplays; i++) {
        videoHandles[i] = 0;
        hwc_display_contents_1_t *content = mCachedDisplays[i];
        if (content == NULL) {
            continue;
        }
        for (int j = 0; j < (int)content->numHwLayers - 1; j++) {
            if (isVideoLayer(content->hwLayers[j])) {
                videoHandles[i] = (intptr_t)content->hwLayers[j].handle;
                if (i > 0) {
                    mIgnoreVideoSkipFlag = !(content->hwLayers[j].flags & HWC_SKIP_LAYER);
                    ITRACE("Ignoring video HWC_SKIP_LAYER: %d on output %d", mIgnoreVideoSkipFlag, i);
                    return;
                }
                break;
            }
        }
    }

    if (videoHandles[0]) {
        WTRACE("Video is on the primary panel only");
        return;
    }

    // video state map indicates video session is active and there is secondary
    // display, need to continue checking as video is not found in the buffers yet
    Event e;
    e.type = VIDEO_CHECK_EVENT;
    postEvent(e);
}

void DisplayAnalyzer::enterVideoExtMode()
{
    if (mVideoExtModeActive) {
        WTRACE("already in video extended mode.");
        return;
    }

    ITRACE("entering video extended mode...");
    mVideoExtModeActive = true;
    Hwcomposer::getInstance().getVsyncManager()->resetVsyncSource();

    setCompositionType(0, HWC_OVERLAY, true);

    // Do not power off primary display immediately as flip is asynchronous
    Event e;
    e.type = DPMS_EVENT;
    e.nValue = 0;
    postEvent(e);
    Hwcomposer::getInstance().invalidate();
}

void DisplayAnalyzer::exitVideoExtMode()
{
    if (!mVideoExtModeActive) {
        WTRACE("Not in video extended mode");
        return;
    }

    ITRACE("exiting video extended mode...");

    mVideoExtModeActive = false;

    Hwcomposer::getInstance().getDrm()->setDpmsMode(
        IDisplayDevice::DEVICE_PRIMARY,
        IDisplayDevice::DEVICE_DISPLAY_ON);

    Hwcomposer::getInstance().getVsyncManager()->resetVsyncSource();

    setCompositionType(0, HWC_FRAMEBUFFER, true);
}

bool DisplayAnalyzer::isPresentationLayer(hwc_layer_1_t &layer)
{
    if (layer.handle == NULL) {
        return false;
    }
    if (mCachedDisplays == NULL) {
        return false;
    }
    // check if the given layer exists in the primary device
    hwc_display_contents_1_t *content = mCachedDisplays[0];
    if (content == NULL) {
        return false;
    }
    for (size_t i = 0; i < content->numHwLayers - 1; i++) {
        if (content->hwLayers[i].handle == layer.handle) {
            VTRACE("Layer exists for Primary device");
            return false;
        }
    }
    return true;
}

bool DisplayAnalyzer::hasProtectedLayer()
{
    DataBuffer * buffer = NULL;
    hwc_display_contents_1_t *content = NULL;
    BufferManager *bm = Hwcomposer::getInstance().getBufferManager();

    if (bm == NULL){
        return false;
    }

    if (mCachedDisplays == NULL) {
        return false;
    }
    // check if the given layer exists in the primary device
    for (int index = 0; index < (int)mCachedNumDisplays; index++) {
        content = mCachedDisplays[index];
        if (content == NULL) {
            continue;
        }

        for (size_t i = 0; i < content->numHwLayers - 1; i++) {
            if (isProtectedLayer(content->hwLayers[i]))
                return true;
        }
    }

    return false;
}

bool DisplayAnalyzer::isProtectedLayer(hwc_layer_1_t &layer)
{
    if (!layer.handle) {
        return false;
    }
    bool ret = false;
    BufferManager *bm = Hwcomposer::getInstance().getBufferManager();
    DataBuffer *buffer = bm->lockDataBuffer(layer.handle);
    if (!buffer) {
        ETRACE("failed to get buffer");
    } else {
        ret = GraphicBuffer::isProtectedBuffer((GraphicBuffer*)buffer);
        bm->unlockDataBuffer(buffer);
    }
    return ret;
}

bool DisplayAnalyzer::ignoreVideoSkipFlag()
{
    return mIgnoreVideoSkipFlag;
}

void DisplayAnalyzer::setCompositionType(hwc_display_contents_1_t *display, int type)
{
    for (size_t i = 0; i < display->numHwLayers - 1; i++) {
        hwc_layer_1_t *layer = &display->hwLayers[i];
        if (layer) layer->compositionType = type;
    }
}

void DisplayAnalyzer::setCompositionType(int device, int type, bool reset)
{
    hwc_display_contents_1_t *content = mCachedDisplays[device];
    if (content == NULL) {
        ETRACE("Invalid device %d", device);
        return;
    }

    // don't need to set geometry changed if layers are just needed to be marked
    if (reset) {
        content->flags |= HWC_GEOMETRY_CHANGED;
    }

    setCompositionType(content, type);
}

int DisplayAnalyzer::getFirstVideoInstanceSessionID() {
    if (mVideoStateMap.size() >= 1) {
        return mVideoStateMap.keyAt(0);
    }
    return -1;
}

} // namespace intel
} // namespace android