| /* |
| // 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 |
| |
