diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk index c9213293b..c2b74ed57 100644 --- a/services/surfaceflinger/Android.mk +++ b/services/surfaceflinger/Android.mk @@ -107,15 +107,16 @@ LOCAL_SHARED_LIBRARIES := \ libgui \ libpowermanager - ifeq ($(TARGET_USES_QCOM_BSP), true) - LOCAL_WHOLE_STATIC_LIBRARIES += libexsurfaceflinger - LOCAL_C_INCLUDES += vendor/qcom/opensource/display-frameworks/native/services/surfaceflinger - LOCAL_C_INCLUDES += vendor/qcom/opensource/display-frameworks/include LOCAL_C_INCLUDES += $(call project-path-for,qcom-display)/libgralloc LOCAL_C_INCLUDES += $(call project-path-for,qcom-display)/libqdutils LOCAL_SHARED_LIBRARIES += libqdutils LOCAL_CFLAGS += -DQTI_BSP + LOCAL_SRC_FILES += \ + ExSurfaceFlinger/ExLayer.cpp \ + ExSurfaceFlinger/ExSurfaceFlinger.cpp \ + ExSurfaceFlinger/ExVirtualDisplaySurface.cpp \ + ExSurfaceFlinger/ExHWComposer.cpp endif ifeq ($(TARGET_HAVE_UI_BLUR),true) diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp index b60687fec..a43597af4 100644 --- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp +++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp @@ -37,7 +37,7 @@ #include #include #ifdef QTI_BSP -#include +#include #endif #include diff --git a/services/surfaceflinger/DisplayUtils.cpp b/services/surfaceflinger/DisplayUtils.cpp index 055523254..96daeacc9 100644 --- a/services/surfaceflinger/DisplayUtils.cpp +++ b/services/surfaceflinger/DisplayUtils.cpp @@ -40,10 +40,10 @@ #include "DisplayHardware/FramebufferSurface.h" #include "DisplayUtils.h" #ifdef QTI_BSP -#include -#include -#include -#include +#include +#include +#include +#include #include #endif #include diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.cpp b/services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.cpp new file mode 100644 index 000000000..2b4109877 --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.cpp @@ -0,0 +1,77 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "ExSurfaceFlinger.h" +#include "ExLayer.h" +#include "ExHWComposer.h" +#ifdef QTI_BSP +#include +#endif + +namespace android { + +ExHWComposer::ExHWComposer(const sp& flinger, + EventHandler& handler) + : HWComposer(flinger, handler) { + + mVDSEnabled = false; + char property[PROPERTY_VALUE_MAX] = {0}; + + /* Read system property for VDS solution. + * This property is expected to be setup once during bootup + */ + if( (property_get("persist.hwc.enable_vds", property, NULL) > 0) && + ((!strncmp(property, "1", strlen("1"))) || + !strncasecmp(property, "true", strlen("true")))) { + /* HAL virtual display is using VDS based implementation */ + mVDSEnabled = true; + } + + mDebugLogs = false; + if((property_get("persist.debug.qdframework.logs", property, NULL) > 0) && + (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || + (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { + mDebugLogs = true; + } + + ALOGD_IF(isDebug(),"Creating custom HWC %s",__FUNCTION__); +} + +ExHWComposer::~ExHWComposer() { +} + +bool ExHWComposer::isCompositionTypeBlit(const int32_t compType) const { +#ifdef QTI_BSP + return (compType == HWC_BLIT); +#else + ALOGD_IF(mDebugLogs, "%s: compType = %d", __FUNCTION__, compType); +#endif + return false; +} + +}; // namespace android diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.h b/services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.h new file mode 100644 index 000000000..2016ff063 --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExHWComposer.h @@ -0,0 +1,57 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ANDROID_EX_HWCOMPOSER_H +#define ANDROID_EX_HWCOMPOSER_H + +#include + +namespace android { + +class ExHWComposer : public HWComposer +{ +public: + + ExHWComposer( + const sp& flinger, + EventHandler& handler); + + virtual ~ExHWComposer(); + +protected: + bool mVDSEnabled; + inline bool isVDSEnabled() const { return mVDSEnabled; }; + bool mDebugLogs; + bool isDebug() { return mDebugLogs; } + bool isCompositionTypeBlit(const int32_t compType) const; +}; + + +}; //namespace android + +#endif //ANDROID_EX_HWCOMPOSER_H diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExLayer.cpp b/services/surfaceflinger/ExSurfaceFlinger/ExLayer.cpp new file mode 100644 index 000000000..fa4557909 --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExLayer.cpp @@ -0,0 +1,207 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include + +#include +#include + +#include +#ifdef QTI_BSP +#include +#include +#endif + +#include "ExLayer.h" + +namespace android { + +/* Calculates the aspect ratio for external display based on the video w/h */ +static Rect getAspectRatio(const sp& hw, + const int& srcWidth, const int& srcHeight) { + Rect outRect; + int fbWidth = hw->getWidth(); + int fbHeight = hw->getHeight(); + int x , y = 0; + int w = fbWidth, h = fbHeight; + if (srcWidth * fbHeight > fbWidth * srcHeight) { + h = fbWidth * srcHeight / srcWidth; + w = fbWidth; + } else if (srcWidth * fbHeight < fbWidth * srcHeight) { + w = fbHeight * srcWidth / srcHeight; + h = fbHeight; + } + x = (fbWidth - w) / 2; + y = (fbHeight - h) / 2; + outRect.left = x; + outRect.top = y; + outRect.right = x + w; + outRect.bottom = y + h; + + return outRect; +} + +ExLayer::ExLayer(SurfaceFlinger* flinger, const sp& client, + const String8& name, uint32_t w, uint32_t h, uint32_t flags) + : Layer(flinger, client, name, w, h, flags) { + + char property[PROPERTY_VALUE_MAX] = {0}; + + mDebugLogs = false; + mIsGPUAllowedForProtected = false; + if((property_get("persist.debug.qdframework.logs", property, NULL) > 0) && + (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || + (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { + mDebugLogs = true; + } + + ALOGD_IF(isDebug(),"Creating custom Layer %s",__FUNCTION__); + + if ((property_get("persist.gralloc.cp.level3", property, NULL) > 0) && + (atoi(property) == 1)) { + mIsGPUAllowedForProtected = true; + } +} + +ExLayer::~ExLayer() { +} + +bool ExLayer::isExtOnly() const { + const sp& activeBuffer(mActiveBuffer); + if (activeBuffer != 0) { +#ifdef QTI_BSP + ANativeWindowBuffer* buffer = activeBuffer->getNativeBuffer(); + if(buffer) { + private_handle_t* hnd = static_cast + (const_cast(buffer->handle)); + /* return true if layer is EXT_ONLY */ + return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY)); + } +#endif + } + return false; +} + +bool ExLayer::isIntOnly() const { + const sp& activeBuffer(mActiveBuffer); + if (activeBuffer != 0) { +#ifdef QTI_BSP + ANativeWindowBuffer* buffer = activeBuffer->getNativeBuffer(); + if(buffer) { + private_handle_t* hnd = static_cast + (const_cast(buffer->handle)); + /* return true if layer is INT_ONLY */ + return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_INTERNAL_ONLY)); + } +#endif + } + return false; +} + +bool ExLayer::isSecureDisplay() const { + const sp& activeBuffer(mActiveBuffer); + if (activeBuffer != 0) { +#ifdef QTI_BSP + ANativeWindowBuffer* buffer = activeBuffer->getNativeBuffer(); + if(buffer) { + private_handle_t* hnd = static_cast + (const_cast(buffer->handle)); + /* return true if layer is SECURE_DISPLAY */ + return (hnd && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY)); + } +#endif + } + return false; +} + +bool ExLayer::isYuvLayer() const { + const sp& activeBuffer(mActiveBuffer); + if(activeBuffer != 0) { +#ifdef QTI_BSP + ANativeWindowBuffer* buffer = activeBuffer->getNativeBuffer(); + if(buffer) { + private_handle_t* hnd = static_cast + (const_cast(buffer->handle)); + /* return true if layer is YUV */ + return (hnd && (hnd->bufferType == BUFFER_TYPE_VIDEO)); + } +#endif + } + return false; +} + +void ExLayer::setPosition(const sp& hw, + HWComposer::HWCLayerInterface& layer, const State& state) { + /* Set dest_rect to display width and height, if external_only flag + * for the layer is enabled or if its yuvLayer in extended mode. + */ + uint32_t w = hw->getWidth(); + uint32_t h = hw->getHeight(); + bool extendedMode = ExSurfaceFlinger::isExtendedMode(); + if(isExtOnly()) { + /* Position: fullscreen for ext_only */ + Rect r(0, 0, w, h); + layer.setFrame(r); + } else if(hw->getDisplayType() > 0 && (extendedMode && isYuvLayer())) { + /* Need to position the video full screen on external with aspect ratio */ + Rect r = getAspectRatio(hw, state.active.w, state.active.h); + layer.setFrame(r); + } + return; +} + +void ExLayer::setAcquiredFenceIfBlit(int &fenceFd, + HWComposer::HWCLayerInterface& layer) { +#ifdef QTI_BSP + if (layer.getCompositionType() == HWC_BLIT) { + sp fence = mSurfaceFlingerConsumer->getCurrentFence(); + if (fence->isValid()) { + fenceFd = fence->dup(); + if (fenceFd == -1) { + ALOGW("%s: failed to dup layer fence, skipping sync: %d", + __FUNCTION__,errno); + } + } + } +#else + ALOGD_IF(isDebug(),"Not a BLIT Layer, compType = %d fencefd = %d", + layer.getCompositionType(), fenceFd); +#endif +} + +bool ExLayer::canAllowGPUForProtected() const { + if(isProtected()) { + return mIsGPUAllowedForProtected; + } else { + return false; + } +} + +}; // namespace android diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExLayer.h b/services/surfaceflinger/ExSurfaceFlinger/ExLayer.h new file mode 100644 index 000000000..01c74a810 --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExLayer.h @@ -0,0 +1,68 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ANDROID_EX_LAYER_H +#define ANDROID_EX_LAYER_H + +#include +#include +#include + +#include +#include "ExSurfaceFlinger.h" + +namespace android { + +class ExSurfaceFlinger; + +class ExLayer : public Layer +{ +public: + ExLayer(SurfaceFlinger* flinger, const sp& client, + const String8& name, uint32_t w, uint32_t h, uint32_t flags); + virtual ~ExLayer(); + + virtual bool isExtOnly() const; + virtual bool isIntOnly() const; + virtual bool isSecureDisplay() const; + virtual bool isYuvLayer() const; + virtual void setPosition(const sp& hw, + HWComposer::HWCLayerInterface& layer, const State& state); + virtual void setAcquiredFenceIfBlit(int &fenceFd, + HWComposer::HWCLayerInterface& layer); + virtual bool canAllowGPUForProtected() const; + +protected: + bool mDebugLogs; + bool isDebug() { return mDebugLogs; } + bool mIsGPUAllowedForProtected; +}; + +}; // namespace android + +#endif // ANDROID_EX_LAYER_H diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExSurfaceFlinger.cpp b/services/surfaceflinger/ExSurfaceFlinger/ExSurfaceFlinger.cpp new file mode 100644 index 000000000..3579abb4b --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExSurfaceFlinger.cpp @@ -0,0 +1,256 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "ExSurfaceFlinger.h" +#include "ExLayer.h" +#include +#ifdef QTI_BSP +#include +#endif +#define ATRACE_TAG ATRACE_TAG_GRAPHICS + +namespace android { + +bool ExSurfaceFlinger::sExtendedMode = false; + +ExSurfaceFlinger::ExSurfaceFlinger() { + char property[PROPERTY_VALUE_MAX] = {0}; + + mDebugLogs = false; + if((property_get("persist.debug.qdframework.logs", property, NULL) > 0) && + (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || + (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { + mDebugLogs = true; + } + + ALOGD_IF(isDebug(),"Creating custom SurfaceFlinger %s",__FUNCTION__); + + mDisableExtAnimation = false; + if((property_get("sys.disable_ext_animation", property, "0") > 0) && + (!strncmp(property, "1", PROPERTY_VALUE_MAX ) || + (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) { + mDisableExtAnimation = true; + } + + ALOGD_IF(isDebug(),"Animation on external is %s in %s", + mDisableExtAnimation ? "disabled" : "not disabled", __FUNCTION__); +} + +ExSurfaceFlinger::~ExSurfaceFlinger() { } + +void ExSurfaceFlinger::updateExtendedMode() { + char prop[PROPERTY_VALUE_MAX]; + property_get("sys.extended_mode", prop, "0"); + sExtendedMode = atoi(prop) ? true : false; +} + +void ExSurfaceFlinger::getIndexLOI(size_t dpy, + const LayerVector& currentLayers, + bool& bIgnoreLayers, + int& indexLOI ) { + size_t i = currentLayers.size(); + while(i--) { + const sp& layer = currentLayers[i]; + /* iterate through the layer list to find ext_only layers and store + * the index + */ + if (layer->isSecureDisplay()) { + bIgnoreLayers = true; + indexLOI = -1; + if(!dpy) + indexLOI = i; + break; + } + /* iterate through the layer list to find ext_only layers or yuv + * layer(extended_mode) and store the index + */ + if ((dpy && (layer->isExtOnly() || + (isExtendedMode() && layer->isYuvLayer())))) { + bIgnoreLayers= true; + indexLOI = i; + } + } + return; +} + +bool ExSurfaceFlinger::updateLayerVisibleNonTransparentRegion( + const int& dpy, const sp& layer, + bool& bIgnoreLayers, int& indexLOI, + uint32_t layerStack, const int& i) { + + const Layer::State& s(layer->getDrawingState()); + + /* Only add the layer marked as "external_only" or yuvLayer + * (extended_mode) to external list and + * only remove the layer marked as "external_only" or yuvLayer in + * extended_mode from primary list + * and do not add the layer marked as "internal_only" to external list + * Add secure UI layers to primary and remove other layers from internal + * and external list + */ + if(((bIgnoreLayers && indexLOI != (int)i) || + (!dpy && layer->isExtOnly()) || + (!dpy && isExtendedMode() && layer->isYuvLayer()))|| + (dpy && layer->isIntOnly())) { + /* Ignore all other layers except the layers marked as ext_only + * by setting visible non transparent region empty + */ + Region visibleNonTransRegion; + visibleNonTransRegion.set(Rect(0,0)); + layer->setVisibleNonTransparentRegion(visibleNonTransRegion); + return true; + } + /* only consider the layers on the given later stack + * Override layers created using presentation class by the layers having + * ext_only flag enabled + */ + if(s.layerStack != layerStack && !bIgnoreLayers) { + /* set the visible region as empty since we have removed the + * layerstack check in rebuildLayerStack() function + */ + Region visibleNonTransRegion; + visibleNonTransRegion.set(Rect(0,0)); + layer->setVisibleNonTransparentRegion(visibleNonTransRegion); + return true; + } + return false; +} + +void ExSurfaceFlinger::delayDPTransactionIfNeeded( + const Vector& displays) { + /* Delay the display projection transaction by 50ms only when the disable + * external rotation animation feature is enabled + */ + if(mDisableExtAnimation) { + size_t count = displays.size(); + for (size_t i=0 ; i= 0) && (s.token != + mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY])) { + const uint32_t what = s.what; + /* Invalidate and Delay the binder thread by 50 ms on + * eDisplayProjectionChanged to trigger a draw cycle so that + * it can fix one incorrect frame on the External, when we + * disable external animation + */ + if (what & DisplayState::eDisplayProjectionChanged) { + invalidateHwcGeometry(); + repaintEverything(); + usleep(50000); + } + } + } + } +} + +bool ExSurfaceFlinger::canDrawLayerinScreenShot( + const sp& hw, + const sp& layer) { + int dispType = hw->getDisplayType(); + /* a) Don't draw SecureDisplayLayer or ProtectedLayer. + * b) Don't let ext_only and extended_mode to be captured + * If not, we would see incorrect image during rotation + * on primary. + */ + if(!layer->isSecureDisplay() + && !layer->isProtected() + && !(!dispType && (layer->isExtOnly() || + (isExtendedMode() && layer->isYuvLayer()))) + && layer->isVisible() ){ + return true; + } + return false; +} + +void ExSurfaceFlinger::isfreezeSurfacePresent(bool& freezeSurfacePresent, + const sp& hw, + const int32_t& id) { + freezeSurfacePresent = false; + /* Get the layers in the current drawing state */ + const LayerVector& layers(mDrawingState.layersSortedByZ); + const size_t layerCount = layers.size(); + /* Look for ScreenShotSurface in external layer list, only when + * disable external rotation animation feature is enabled + */ + if(mDisableExtAnimation && (id != HWC_DISPLAY_PRIMARY)) { + for (size_t i = 0 ; i < layerCount ; ++i) { + static int screenShotLen = strlen("ScreenshotSurface"); + const sp& layer(layers[i]); + const Layer::State& s(layer->getDrawingState()); + /* check the layers associated with external display */ + if(s.layerStack == hw->getLayerStack()) { + if(!strncmp(layer->getName(), "ScreenshotSurface", + screenShotLen)) { + /* Screenshot layer is present, and animation in + * progress + */ + freezeSurfacePresent = true; + break; + } + } + } + } +} + +void ExSurfaceFlinger::setOrientationEventControl(bool& freezeSurfacePresent, + const int32_t& id) { + HWComposer& hwc(getHwComposer()); + HWComposer::LayerListIterator cur = hwc.begin(id); + + if(freezeSurfacePresent) { + /* If freezeSurfacePresent, set ANIMATING flag + * which is used to support disable animation on external + */ + cur->setAnimating(true); + } +} + +void ExSurfaceFlinger::updateVisibleRegionsDirty() { + /* If extended_mode is set, and set mVisibleRegionsDirty + * as we need to rebuildLayerStack + */ + if(isExtendedMode()) { + mVisibleRegionsDirty = true; + } +} + +void ExSurfaceFlinger::drawWormHoleIfRequired(HWComposer::LayerListIterator& cur, + const HWComposer::LayerListIterator& end, + const sp& hw, + const Region& region) { + if (cur != end) { +#ifdef QTI_BSP + if (cur->getCompositionType() != HWC_BLIT) + drawWormhole(hw, region); +#endif + } else { + drawWormhole(hw, region); + } +} + +}; // namespace android diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExSurfaceFlinger.h b/services/surfaceflinger/ExSurfaceFlinger/ExSurfaceFlinger.h new file mode 100644 index 000000000..628fac7f0 --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExSurfaceFlinger.h @@ -0,0 +1,86 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ANDROID_EX_SURFACE_FLINGER_H +#define ANDROID_EX_SURFACE_FLINGER_H + +#include "SurfaceFlinger.h" + +namespace android { + +class ExSurfaceFlinger : public SurfaceFlinger +{ +public: + + ExSurfaceFlinger(); + +protected: + friend class ExLayer; + + virtual void updateExtendedMode(); + virtual void getIndexLOI(size_t dpy, + const LayerVector& currentLayers, + bool& bIgnoreLayers, + int& indexLOI); + virtual bool updateLayerVisibleNonTransparentRegion( + const int& dpy, const sp& layer, + bool& bIgnoreLayers, int& indexLOI, + uint32_t layerStack, const int& i); + virtual void delayDPTransactionIfNeeded( + const Vector& displays); + virtual bool canDrawLayerinScreenShot( + const sp& hw, + const sp& layer); + virtual void isfreezeSurfacePresent( + bool& freezeSurfacePresent, + const sp& hw, + const int32_t& id); + virtual void setOrientationEventControl( + bool& freezeSurfacePresent, + const int32_t& id); + virtual void updateVisibleRegionsDirty(); + virtual void drawWormHoleIfRequired(HWComposer::LayerListIterator& /*cur*/, + const HWComposer::LayerListIterator& /*end*/, + const sp& hw, + const Region& region); + virtual ~ExSurfaceFlinger(); + + /* Extended Mode + * No video on primary but video will be shown full + * screen on External + */ + static bool sExtendedMode; + static bool isExtendedMode() { return sExtendedMode; } + bool mDebugLogs; + bool isDebug() { return mDebugLogs; } + bool mDisableExtAnimation; +}; + +}; //namespace android + +#endif //ANDROID_EX_SURFACE_FLINGER_H diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExVirtualDisplaySurface.cpp b/services/surfaceflinger/ExSurfaceFlinger/ExVirtualDisplaySurface.cpp new file mode 100644 index 000000000..e4ad75831 --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExVirtualDisplaySurface.cpp @@ -0,0 +1,93 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "ExVirtualDisplaySurface.h" +#ifdef QTI_BSP +#include +#endif + +namespace android { + +#define VDS_LOGE(msg, ...) ALOGE("[%s] " msg, \ + mDisplayName.string(), ##__VA_ARGS__) +#define VDS_LOGW_IF(cond, msg, ...) ALOGW_IF(cond, "[%s] " msg, \ + mDisplayName.string(), ##__VA_ARGS__) +#define VDS_LOGV(msg, ...) ALOGV("[%s] " msg, \ + mDisplayName.string(), ##__VA_ARGS__) + +ExVirtualDisplaySurface::ExVirtualDisplaySurface(HWComposer& hwc, int32_t dispId, + const sp& sink, + const sp& bqProducer, + const sp& bqConsumer, + const String8& name, + bool secure) +: VirtualDisplaySurface(hwc, dispId, sink, bqProducer, bqConsumer, name), + mSecure(secure) { + sink->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS, &mSinkUsage); + mSinkUsage |= GRALLOC_USAGE_HW_COMPOSER; + setOutputUsage(mSinkUsage); +} + +status_t ExVirtualDisplaySurface::beginFrame(bool mustRecompose) { + if (mDisplayId < 0) + return NO_ERROR; + + mMustRecompose = mustRecompose; + /* For WFD use cases we must always set the recompose flag in order + * to support pause/resume functionality + */ + if (mOutputUsage & GRALLOC_USAGE_HW_VIDEO_ENCODER) { + mMustRecompose = true; + } + + VDS_LOGW_IF(mDbgState != DBG_STATE_IDLE, + "Unexpected beginFrame() in %s state", dbgStateStr()); + mDbgState = DBG_STATE_BEGUN; + + return refreshOutputBuffer(); + +} + +/* Helper to update the output usage when the display is secure */ +void ExVirtualDisplaySurface::setOutputUsage(uint32_t /*flag*/) { + mOutputUsage = mSinkUsage; + if (mSecure && (mOutputUsage & GRALLOC_USAGE_HW_VIDEO_ENCODER)) { + /* TODO: Currently, the framework can only say whether the display + * and its subsequent session are secure or not. However, there is + * no mechanism to distinguish the different levels of security. + * The current solution assumes WV L3 protection. + */ + mOutputUsage |= GRALLOC_USAGE_PROTECTED; +#ifdef QTI_BSP + mOutputUsage |= GRALLOC_USAGE_PRIVATE_MM_HEAP | + GRALLOC_USAGE_PRIVATE_UNCACHED; +#endif + } +} + +}; // namespace android diff --git a/services/surfaceflinger/ExSurfaceFlinger/ExVirtualDisplaySurface.h b/services/surfaceflinger/ExSurfaceFlinger/ExVirtualDisplaySurface.h new file mode 100644 index 000000000..ab715944e --- /dev/null +++ b/services/surfaceflinger/ExSurfaceFlinger/ExVirtualDisplaySurface.h @@ -0,0 +1,55 @@ +/* Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ANDROID_EX_VIRTUAL_DISPLAY_SURFACE_H +#define ANDROID_EX_VIRTUAL_DISPLAY_SURFACE_H + +#include + +namespace android { + +class ExVirtualDisplaySurface : public VirtualDisplaySurface { +public: + ExVirtualDisplaySurface(HWComposer& hwc, int32_t dispId, + const sp& sink, + const sp& bqProducer, + const sp& bqConsumer, + const String8& name, + bool secure); + +private: + virtual status_t beginFrame(bool mustRecompose); + virtual void setOutputUsage(uint32_t flag); + bool mSecure; + int mSinkUsage; +}; + +}; // namespace android + +#endif // ANDROID_EX_VIRTUAL_DISPLAY_SURFACE_H +