diff options
Diffstat (limited to 'services/surfaceflinger/BufferLayer.cpp')
| -rw-r--r-- | services/surfaceflinger/BufferLayer.cpp | 1004 |
1 files changed, 366 insertions, 638 deletions
diff --git a/services/surfaceflinger/BufferLayer.cpp b/services/surfaceflinger/BufferLayer.cpp index 707cb42336..f51fbb45f6 100644 --- a/services/surfaceflinger/BufferLayer.cpp +++ b/services/surfaceflinger/BufferLayer.cpp @@ -20,76 +20,64 @@ #define ATRACE_TAG ATRACE_TAG_GRAPHICS #include "BufferLayer.h" -#include "Colorizer.h" -#include "DisplayDevice.h" -#include "LayerRejecter.h" -#include "clz.h" - -#include "RenderEngine/RenderEngine.h" +#include <compositionengine/CompositionEngine.h> +#include <compositionengine/Display.h> +#include <compositionengine/Layer.h> +#include <compositionengine/LayerCreationArgs.h> +#include <compositionengine/OutputLayer.h> +#include <compositionengine/impl/LayerCompositionState.h> +#include <compositionengine/impl/OutputLayerCompositionState.h> +#include <cutils/compiler.h> +#include <cutils/native_handle.h> +#include <cutils/properties.h> #include <gui/BufferItem.h> #include <gui/BufferQueue.h> #include <gui/LayerDebugInfo.h> #include <gui/Surface.h> - +#include <renderengine/RenderEngine.h> #include <ui/DebugUtils.h> - #include <utils/Errors.h> #include <utils/Log.h> #include <utils/NativeHandle.h> #include <utils/StopWatch.h> #include <utils/Trace.h> -#include <cutils/compiler.h> -#include <cutils/native_handle.h> -#include <cutils/properties.h> - -#include <math.h> -#include <stdlib.h> +#include <cmath> +#include <cstdlib> #include <mutex> +#include <sstream> -namespace android { - -BufferLayer::BufferLayer(SurfaceFlinger* flinger, const sp<Client>& client, const String8& name, - uint32_t w, uint32_t h, uint32_t flags) - : Layer(flinger, client, name, w, h, flags), - mConsumer(nullptr), - mTextureName(UINT32_MAX), - mFormat(PIXEL_FORMAT_NONE), - mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE), - mBufferLatched(false), - mPreviousFrameNumber(0), - mUpdateTexImageFailed(false), - mRefreshPending(false) { - ALOGV("Creating Layer %s", name.string()); +#include "Colorizer.h" +#include "DisplayDevice.h" +#include "LayerRejecter.h" +#include "TimeStats/TimeStats.h" - mTextureName = mFlinger->getNewTexture(); - mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName); +namespace android { - if (flags & ISurfaceComposerClient::eNonPremultiplied) mPremultipliedAlpha = false; +BufferLayer::BufferLayer(const LayerCreationArgs& args) + : Layer(args), + mTextureName(args.flinger->getNewTexture()), + mCompositionLayer{mFlinger->getCompositionEngine().createLayer( + compositionengine::LayerCreationArgs{this})} { + ALOGV("Creating Layer %s", args.name.string()); - mCurrentState.requested = mCurrentState.active; + mPremultipliedAlpha = !(args.flags & ISurfaceComposerClient::eNonPremultiplied); - // drawing state & current state are identical - mDrawingState = mCurrentState; + mPotentialCursor = args.flags & ISurfaceComposerClient::eCursorWindow; + mProtectedByApp = args.flags & ISurfaceComposerClient::eProtectedByApp; } BufferLayer::~BufferLayer() { mFlinger->deleteTextureAsync(mTextureName); - - if (!getBE().mHwcLayers.empty()) { - ALOGE("Found stale hardware composer layers when destroying " - "surface flinger layer %s", - mName.string()); - destroyAllHwcLayers(); - } + mFlinger->mTimeStats->onDestroy(getSequence()); } void BufferLayer::useSurfaceDamage() { if (mFlinger->mForceFullDamage) { surfaceDamageRegion = Region::INVALID_REGION; } else { - surfaceDamageRegion = mConsumer->getSurfaceDamage(); + surfaceDamageRegion = getDrawingSurfaceDamage(); } } @@ -97,44 +85,32 @@ void BufferLayer::useEmptyDamage() { surfaceDamageRegion.clear(); } -bool BufferLayer::isProtected() const { - const sp<GraphicBuffer>& buffer(getBE().compositionInfo.mBuffer); - return (buffer != 0) && - (buffer->getUsage() & GRALLOC_USAGE_PROTECTED); +bool BufferLayer::isOpaque(const Layer::State& s) const { + // if we don't have a buffer or sidebandStream yet, we're translucent regardless of the + // layer's opaque flag. + if ((mSidebandStream == nullptr) && (mActiveBuffer == nullptr)) { + return false; + } + + // if the layer has the opaque flag, then we're always opaque, + // otherwise we use the current buffer's format. + return ((s.flags & layer_state_t::eLayerOpaque) != 0) || getOpacityForFormat(getPixelFormat()); } bool BufferLayer::isVisible() const { - return !(isHiddenByPolicy()) && getAlpha() > 0.0f && - (getBE().compositionInfo.mBuffer != nullptr || - getBE().compositionInfo.hwc.sidebandStream != nullptr); + bool visible = !(isHiddenByPolicy()) && getAlpha() > 0.0f && + (mActiveBuffer != nullptr || mSidebandStream != nullptr); + mFlinger->mScheduler->setLayerVisibility(mSchedulerLayerHandle, visible); + + return visible; } bool BufferLayer::isFixedSize() const { return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE; } -status_t BufferLayer::setBuffers(uint32_t w, uint32_t h, PixelFormat format, uint32_t flags) { - uint32_t const maxSurfaceDims = - min(mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims()); - - // never allow a surface larger than what our underlying GL implementation - // can handle. - if ((uint32_t(w) > maxSurfaceDims) || (uint32_t(h) > maxSurfaceDims)) { - ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h)); - return BAD_VALUE; - } - - mFormat = format; - - mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false; - mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false; - mCurrentOpacity = getOpacityForFormat(format); - - mConsumer->setDefaultBufferSize(w, h); - mConsumer->setDefaultBufferFormat(format); - mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); - - return NO_ERROR; +bool BufferLayer::usesSourceCrop() const { + return true; } static constexpr mat4 inverseOrientation(uint32_t transform) { @@ -155,14 +131,14 @@ static constexpr mat4 inverseOrientation(uint32_t transform) { return inverse(tr); } -/* - * onDraw will draw the current layer onto the presentable buffer - */ -void BufferLayer::onDraw(const RenderArea& renderArea, const Region& clip, - bool useIdentityTransform) const { +bool BufferLayer::prepareClientLayer(const RenderArea& renderArea, const Region& clip, + bool useIdentityTransform, Region& clearRegion, + const bool supportProtectedContent, + renderengine::LayerSettings& layer) { ATRACE_CALL(); - - if (CC_UNLIKELY(getBE().compositionInfo.mBuffer == 0)) { + Layer::prepareClientLayer(renderArea, clip, useIdentityTransform, clearRegion, + supportProtectedContent, layer); + if (CC_UNLIKELY(mActiveBuffer == 0)) { // the texture has not been created yet, this Layer has // in fact never been drawn into. This happens frequently with // SurfaceView because the WindowManager can't know when the client @@ -179,37 +155,33 @@ void BufferLayer::onDraw(const RenderArea& renderArea, const Region& clip, finished = true; return; } - under.orSelf(renderArea.getTransform().transform(layer->visibleRegion)); + under.orSelf(layer->visibleRegion); }); // if not everything below us is covered, we plug the holes! Region holes(clip.subtract(under)); if (!holes.isEmpty()) { - clearWithOpenGL(renderArea, 0, 0, 0, 1); + clearRegion.orSelf(holes); } - return; - } - - // Bind the current buffer to the GL texture, and wait for it to be - // ready for us to draw into. - status_t err = mConsumer->bindTextureImage(); - if (err != NO_ERROR) { - ALOGW("onDraw: bindTextureImage failed (err=%d)", err); - // Go ahead and draw the buffer anyway; no matter what we do the screen - // is probably going to have something visibly wrong. + return false; } - - bool blackOutLayer = isProtected() || (isSecure() && !renderArea.isSecure()); - - auto& engine(mFlinger->getRenderEngine()); - + bool blackOutLayer = + (isProtected() && !supportProtectedContent) || (isSecure() && !renderArea.isSecure()); + const State& s(getDrawingState()); if (!blackOutLayer) { + layer.source.buffer.buffer = mActiveBuffer; + layer.source.buffer.isOpaque = isOpaque(s); + layer.source.buffer.fence = mActiveBufferFence; + layer.source.buffer.textureName = mTextureName; + layer.source.buffer.usePremultipliedAlpha = getPremultipledAlpha(); + layer.source.buffer.isY410BT2020 = isHdrY410(); // TODO: we could be more subtle with isFixedSize() - const bool useFiltering = needsFiltering(renderArea) || isFixedSize(); + const bool useFiltering = needsFiltering(renderArea.getDisplayDevice()) || + renderArea.needsFiltering() || isFixedSize(); // Query the texture matrix given our current filtering mode. float textureMatrix[16]; - mConsumer->setFilteringEnabled(useFiltering); - mConsumer->getTransformMatrix(textureMatrix); + setFilteringEnabled(useFiltering); + getDrawingTransformMatrix(textureMatrix); if (getTransformToDisplayInverse()) { /* @@ -239,66 +211,145 @@ void BufferLayer::onDraw(const RenderArea& renderArea, const Region& clip, memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix)); } - // Set things up for texturing. - mTexture.setDimensions(getBE().compositionInfo.mBuffer->getWidth(), - getBE().compositionInfo.mBuffer->getHeight()); - mTexture.setFiltering(useFiltering); - mTexture.setMatrix(textureMatrix); + const Rect win{getBounds()}; + float bufferWidth = getBufferSize(s).getWidth(); + float bufferHeight = getBufferSize(s).getHeight(); + + // BufferStateLayers can have a "buffer size" of [0, 0, -1, -1] when no display frame has + // been set and there is no parent layer bounds. In that case, the scale is meaningless so + // ignore them. + if (!getBufferSize(s).isValid()) { + bufferWidth = float(win.right) - float(win.left); + bufferHeight = float(win.bottom) - float(win.top); + } + + const float scaleHeight = (float(win.bottom) - float(win.top)) / bufferHeight; + const float scaleWidth = (float(win.right) - float(win.left)) / bufferWidth; + const float translateY = float(win.top) / bufferHeight; + const float translateX = float(win.left) / bufferWidth; + + // Flip y-coordinates because GLConsumer expects OpenGL convention. + mat4 tr = mat4::translate(vec4(.5, .5, 0, 1)) * mat4::scale(vec4(1, -1, 1, 1)) * + mat4::translate(vec4(-.5, -.5, 0, 1)) * + mat4::translate(vec4(translateX, translateY, 0, 1)) * + mat4::scale(vec4(scaleWidth, scaleHeight, 1.0, 1.0)); - engine.setupLayerTexturing(mTexture); + layer.source.buffer.useTextureFiltering = useFiltering; + layer.source.buffer.textureTransform = mat4(static_cast<const float*>(textureMatrix)) * tr; } else { - engine.setupLayerBlackedOut(); + // If layer is blacked out, force alpha to 1 so that we draw a black color + // layer. + layer.source.buffer.buffer = nullptr; + layer.alpha = 1.0; } - drawWithOpenGL(renderArea, useIdentityTransform); - engine.disableTexturing(); -} -void BufferLayer::onLayerDisplayed(const sp<Fence>& releaseFence) { - mConsumer->setReleaseFence(releaseFence); + return true; } -void BufferLayer::abandon() { - mConsumer->abandon(); +bool BufferLayer::isHdrY410() const { + // pixel format is HDR Y410 masquerading as RGBA_1010102 + return (mCurrentDataSpace == ui::Dataspace::BT2020_ITU_PQ && + getDrawingApi() == NATIVE_WINDOW_API_MEDIA && + mActiveBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102); } -bool BufferLayer::shouldPresentNow(const DispSync& dispSync) const { - if (mSidebandStreamChanged || mAutoRefresh) { - return true; +void BufferLayer::setPerFrameData(const sp<const DisplayDevice>& displayDevice, + const ui::Transform& transform, const Rect& viewport, + int32_t supportedPerFrameMetadata, + const ui::Dataspace targetDataspace) { + RETURN_IF_NO_HWC_LAYER(displayDevice); + + // Apply this display's projection's viewport to the visible region + // before giving it to the HWC HAL. + Region visible = transform.transform(visibleRegion.intersect(viewport)); + + const auto outputLayer = findOutputLayerForDisplay(displayDevice); + LOG_FATAL_IF(!outputLayer || !outputLayer->getState().hwc); + + auto& hwcLayer = (*outputLayer->getState().hwc).hwcLayer; + auto error = hwcLayer->setVisibleRegion(visible); + if (error != HWC2::Error::None) { + ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(), + to_string(error).c_str(), static_cast<int32_t>(error)); + visible.dump(LOG_TAG); } + outputLayer->editState().visibleRegion = visible; - Mutex::Autolock lock(mQueueItemLock); - if (mQueueItems.empty()) { - return false; + auto& layerCompositionState = getCompositionLayer()->editState().frontEnd; + + error = hwcLayer->setSurfaceDamage(surfaceDamageRegion); + if (error != HWC2::Error::None) { + ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(), + to_string(error).c_str(), static_cast<int32_t>(error)); + surfaceDamageRegion.dump(LOG_TAG); + } + layerCompositionState.surfaceDamage = surfaceDamageRegion; + + // Sideband layers + if (layerCompositionState.sidebandStream.get()) { + setCompositionType(displayDevice, Hwc2::IComposerClient::Composition::SIDEBAND); + ALOGV("[%s] Requesting Sideband composition", mName.string()); + error = hwcLayer->setSidebandStream(layerCompositionState.sidebandStream->handle()); + if (error != HWC2::Error::None) { + ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(), + layerCompositionState.sidebandStream->handle(), to_string(error).c_str(), + static_cast<int32_t>(error)); + } + layerCompositionState.compositionType = Hwc2::IComposerClient::Composition::SIDEBAND; + return; } - auto timestamp = mQueueItems[0].mTimestamp; - nsecs_t expectedPresent = mConsumer->computeExpectedPresent(dispSync); - // Ignore timestamps more than a second in the future - bool isPlausible = timestamp < (expectedPresent + s2ns(1)); - ALOGW_IF(!isPlausible, - "[%s] Timestamp %" PRId64 " seems implausible " - "relative to expectedPresent %" PRId64, - mName.string(), timestamp, expectedPresent); + // Device or Cursor layers + if (mPotentialCursor) { + ALOGV("[%s] Requesting Cursor composition", mName.string()); + setCompositionType(displayDevice, Hwc2::IComposerClient::Composition::CURSOR); + } else { + ALOGV("[%s] Requesting Device composition", mName.string()); + setCompositionType(displayDevice, Hwc2::IComposerClient::Composition::DEVICE); + } - bool isDue = timestamp < expectedPresent; - return isDue || !isPlausible; -} + ui::Dataspace dataspace = isColorSpaceAgnostic() && targetDataspace != ui::Dataspace::UNKNOWN + ? targetDataspace + : mCurrentDataSpace; + error = hwcLayer->setDataspace(dataspace); + if (error != HWC2::Error::None) { + ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), dataspace, + to_string(error).c_str(), static_cast<int32_t>(error)); + } -void BufferLayer::setTransformHint(uint32_t orientation) const { - mConsumer->setTransformHint(orientation); + const HdrMetadata& metadata = getDrawingHdrMetadata(); + error = hwcLayer->setPerFrameMetadata(supportedPerFrameMetadata, metadata); + if (error != HWC2::Error::None && error != HWC2::Error::Unsupported) { + ALOGE("[%s] Failed to set hdrMetadata: %s (%d)", mName.string(), + to_string(error).c_str(), static_cast<int32_t>(error)); + } + + error = hwcLayer->setColorTransform(getColorTransform()); + if (error == HWC2::Error::Unsupported) { + // If per layer color transform is not supported, we use GPU composition. + setCompositionType(displayDevice, Hwc2::IComposerClient::Composition::CLIENT); + } else if (error != HWC2::Error::None) { + ALOGE("[%s] Failed to setColorTransform: %s (%d)", mName.string(), + to_string(error).c_str(), static_cast<int32_t>(error)); + } + layerCompositionState.dataspace = mCurrentDataSpace; + layerCompositionState.colorTransform = getColorTransform(); + layerCompositionState.hdrMetadata = metadata; + + setHwcLayerBuffer(displayDevice); } bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) { if (mBufferLatched) { Mutex::Autolock lock(mFrameEventHistoryMutex); - mFrameEventHistory.addPreComposition(mCurrentFrameNumber, - refreshStartTime); + mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime); } mRefreshPending = false; - return mQueuedFrames > 0 || mSidebandStreamChanged || - mAutoRefresh; + return hasReadyFrame(); } -bool BufferLayer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence, + +bool BufferLayer::onPostComposition(const std::optional<DisplayId>& displayId, + const std::shared_ptr<FenceTime>& glDoneFence, const std::shared_ptr<FenceTime>& presentFence, const CompositorTiming& compositorTiming) { // mFrameLatencyNeeded is true when a new frame was latched for the @@ -308,18 +359,18 @@ bool BufferLayer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFenc // Update mFrameEventHistory. { Mutex::Autolock lock(mFrameEventHistoryMutex); - mFrameEventHistory.addPostComposition(mCurrentFrameNumber, glDoneFence, - presentFence, compositorTiming); + mFrameEventHistory.addPostComposition(mCurrentFrameNumber, glDoneFence, presentFence, + compositorTiming); } // Update mFrameTracker. - nsecs_t desiredPresentTime = mConsumer->getTimestamp(); + nsecs_t desiredPresentTime = getDesiredPresentTime(); mFrameTracker.setDesiredPresentTime(desiredPresentTime); - const std::string layerName(getName().c_str()); - mTimeStats.setDesiredTime(layerName, mCurrentFrameNumber, desiredPresentTime); + const int32_t layerID = getSequence(); + mFlinger->mTimeStats->setDesiredTime(layerID, mCurrentFrameNumber, desiredPresentTime); - std::shared_ptr<FenceTime> frameReadyFence = mConsumer->getCurrentFenceTime(); + std::shared_ptr<FenceTime> frameReadyFence = getCurrentFenceTime(); if (frameReadyFence->isValid()) { mFrameTracker.setFrameReadyFence(std::move(frameReadyFence)); } else { @@ -329,14 +380,13 @@ bool BufferLayer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFenc } if (presentFence->isValid()) { - mTimeStats.setPresentFence(layerName, mCurrentFrameNumber, presentFence); + mFlinger->mTimeStats->setPresentFence(layerID, mCurrentFrameNumber, presentFence); mFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence)); - } else { + } else if (displayId && mFlinger->getHwComposer().isConnected(*displayId)) { // The HWC doesn't support present fences, so use the refresh // timestamp instead. - const nsecs_t actualPresentTime = - mFlinger->getHwComposer().getRefreshTimestamp(HWC_DISPLAY_PRIMARY); - mTimeStats.setPresentTime(layerName, mCurrentFrameNumber, actualPresentTime); + const nsecs_t actualPresentTime = mFlinger->getHwComposer().getRefreshTimestamp(*displayId); + mFlinger->mTimeStats->setPresentTime(layerID, mCurrentFrameNumber, actualPresentTime); mFrameTracker.setActualPresentTime(actualPresentTime); } @@ -345,58 +395,17 @@ bool BufferLayer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFenc return true; } -std::vector<OccupancyTracker::Segment> BufferLayer::getOccupancyHistory(bool forceFlush) { - std::vector<OccupancyTracker::Segment> history; - status_t result = mConsumer->getOccupancyHistory(forceFlush, &history); - if (result != NO_ERROR) { - ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(), result); - return {}; - } - return history; -} - -bool BufferLayer::getTransformToDisplayInverse() const { - return mConsumer->getTransformToDisplayInverse(); -} - -void BufferLayer::releasePendingBuffer(nsecs_t dequeueReadyTime) { - if (!mConsumer->releasePendingBuffer()) { - return; - } - - auto releaseFenceTime = - std::make_shared<FenceTime>(mConsumer->getPrevFinalReleaseFence()); - mReleaseTimeline.updateSignalTimes(); - mReleaseTimeline.push(releaseFenceTime); - - Mutex::Autolock lock(mFrameEventHistoryMutex); - if (mPreviousFrameNumber != 0) { - mFrameEventHistory.addRelease(mPreviousFrameNumber, dequeueReadyTime, - std::move(releaseFenceTime)); - } -} - -Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) { +bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) { ATRACE_CALL(); - if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) { - // mSidebandStreamChanged was true - mSidebandStream = mConsumer->getSidebandStream(); - // replicated in LayerBE until FE/BE is ready to be synchronized - getBE().compositionInfo.hwc.sidebandStream = mSidebandStream; - if (getBE().compositionInfo.hwc.sidebandStream != nullptr) { - setTransactionFlags(eTransactionNeeded); - mFlinger->setTransactionFlags(eTraversalNeeded); - } - recomputeVisibleRegions = true; + bool refreshRequired = latchSidebandStream(recomputeVisibleRegions); - const State& s(getDrawingState()); - return getTransform().transform(Region(Rect(s.active.w, s.active.h))); + if (refreshRequired) { + return refreshRequired; } - Region outDirtyRegion; - if (mQueuedFrames <= 0 && !mAutoRefresh) { - return outDirtyRegion; + if (!hasReadyFrame()) { + return false; } // if we've already called updateTexImage() without going through @@ -405,119 +414,42 @@ Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime // compositionComplete() call. // we'll trigger an update in onPreComposition(). if (mRefreshPending) { - return outDirtyRegion; + return false; } // If the head buffer's acquire fence hasn't signaled yet, return and // try again later - if (!headFenceHasSignaled()) { + if (!fenceHasSignaled()) { + ATRACE_NAME("!fenceHasSignaled()"); mFlinger->signalLayerUpdate(); - return outDirtyRegion; + return false; } // Capture the old state of the layer for comparisons later const State& s(getDrawingState()); const bool oldOpacity = isOpaque(s); - sp<GraphicBuffer> oldBuffer = getBE().compositionInfo.mBuffer; + sp<GraphicBuffer> oldBuffer = mActiveBuffer; if (!allTransactionsSignaled()) { - mFlinger->signalLayerUpdate(); - return outDirtyRegion; - } - - // This boolean is used to make sure that SurfaceFlinger's shadow copy - // of the buffer queue isn't modified when the buffer queue is returning - // BufferItem's that weren't actually queued. This can happen in shared - // buffer mode. - bool queuedBuffer = false; - LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions, - getProducerStickyTransform() != 0, mName.string(), - mOverrideScalingMode, mFreezeGeometryUpdates); - status_t updateResult = - mConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync, - &mAutoRefresh, &queuedBuffer, - mLastFrameNumberReceived); - if (updateResult == BufferQueue::PRESENT_LATER) { - // Producer doesn't want buffer to be displayed yet. Signal a - // layer update so we check again at the next opportunity. - mFlinger->signalLayerUpdate(); - return outDirtyRegion; - } else if (updateResult == BufferLayerConsumer::BUFFER_REJECTED) { - // If the buffer has been rejected, remove it from the shadow queue - // and return early - if (queuedBuffer) { - Mutex::Autolock lock(mQueueItemLock); - mTimeStats.removeTimeRecord(getName().c_str(), mQueueItems[0].mFrameNumber); - mQueueItems.removeAt(0); - android_atomic_dec(&mQueuedFrames); - } - return outDirtyRegion; - } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { - // This can occur if something goes wrong when trying to create the - // EGLImage for this buffer. If this happens, the buffer has already - // been released, so we need to clean up the queue and bug out - // early. - if (queuedBuffer) { - Mutex::Autolock lock(mQueueItemLock); - mQueueItems.clear(); - android_atomic_and(0, &mQueuedFrames); - mTimeStats.clearLayerRecord(getName().c_str()); - } - - // Once we have hit this state, the shadow queue may no longer - // correctly reflect the incoming BufferQueue's contents, so even if - // updateTexImage starts working, the only safe course of action is - // to continue to ignore updates. - mUpdateTexImageFailed = true; - - return outDirtyRegion; - } - - if (queuedBuffer) { - // Autolock scope - auto currentFrameNumber = mConsumer->getFrameNumber(); - - Mutex::Autolock lock(mQueueItemLock); - - // Remove any stale buffers that have been dropped during - // updateTexImage - while (mQueueItems[0].mFrameNumber != currentFrameNumber) { - mTimeStats.removeTimeRecord(getName().c_str(), mQueueItems[0].mFrameNumber); - mQueueItems.removeAt(0); - android_atomic_dec(&mQueuedFrames); - } - - const std::string layerName(getName().c_str()); - mTimeStats.setAcquireFence(layerName, currentFrameNumber, mQueueItems[0].mFenceTime); - mTimeStats.setLatchTime(layerName, currentFrameNumber, latchTime); - - mQueueItems.removeAt(0); + mFlinger->setTransactionFlags(eTraversalNeeded); + return false; } - // Decrement the queued-frames count. Signal another event if we - // have more frames pending. - if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1) || - mAutoRefresh) { - mFlinger->signalLayerUpdate(); + status_t err = updateTexImage(recomputeVisibleRegions, latchTime); + if (err != NO_ERROR) { + return false; } - // update the active buffer - getBE().compositionInfo.mBuffer = - mConsumer->getCurrentBuffer(&getBE().compositionInfo.mBufferSlot); - // replicated in LayerBE until FE/BE is ready to be synchronized - mActiveBuffer = getBE().compositionInfo.mBuffer; - if (getBE().compositionInfo.mBuffer == nullptr) { - // this can only happen if the very first buffer was rejected. - return outDirtyRegion; + err = updateActiveBuffer(); + if (err != NO_ERROR) { + return false; } mBufferLatched = true; - mPreviousFrameNumber = mCurrentFrameNumber; - mCurrentFrameNumber = mConsumer->getFrameNumber(); - { - Mutex::Autolock lock(mFrameEventHistoryMutex); - mFrameEventHistory.addLatch(mCurrentFrameNumber, latchTime); + err = updateFrameNumber(latchTime); + if (err != NO_ERROR) { + return false; } mRefreshPending = true; @@ -528,55 +460,54 @@ Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime recomputeVisibleRegions = true; } - ui::Dataspace dataSpace = mConsumer->getCurrentDataSpace(); - // treat modern dataspaces as legacy dataspaces whenever possible, until - // we can trust the buffer producers + ui::Dataspace dataSpace = getDrawingDataSpace(); + // translate legacy dataspaces to modern dataspaces switch (dataSpace) { - case ui::Dataspace::V0_SRGB: - dataSpace = ui::Dataspace::SRGB; + case ui::Dataspace::SRGB: + dataSpace = ui::Dataspace::V0_SRGB; break; - case ui::Dataspace::V0_SRGB_LINEAR: - dataSpace = ui::Dataspace::SRGB_LINEAR; + case ui::Dataspace::SRGB_LINEAR: + dataSpace = ui::Dataspace::V0_SRGB_LINEAR; break; - case ui::Dataspace::V0_JFIF: - dataSpace = ui::Dataspace::JFIF; + case ui::Dataspace::JFIF: + dataSpace = ui::Dataspace::V0_JFIF; break; - case ui::Dataspace::V0_BT601_625: - dataSpace = ui::Dataspace::BT601_625; + case ui::Dataspace::BT601_625: + dataSpace = ui::Dataspace::V0_BT601_625; break; - case ui::Dataspace::V0_BT601_525: - dataSpace = ui::Dataspace::BT601_525; + case ui::Dataspace::BT601_525: + dataSpace = ui::Dataspace::V0_BT601_525; break; - case ui::Dataspace::V0_BT709: - dataSpace = ui::Dataspace::BT709; + case ui::Dataspace::BT709: + dataSpace = ui::Dataspace::V0_BT709; break; default: break; } mCurrentDataSpace = dataSpace; - Rect crop(mConsumer->getCurrentCrop()); - const uint32_t transform(mConsumer->getCurrentTransform()); - const uint32_t scalingMode(mConsumer->getCurrentScalingMode()); - if ((crop != mCurrentCrop) || - (transform != mCurrentTransform) || - (scalingMode != mCurrentScalingMode)) { + Rect crop(getDrawingCrop()); + const uint32_t transform(getDrawingTransform()); + const uint32_t scalingMode(getDrawingScalingMode()); + const bool transformToDisplayInverse(getTransformToDisplayInverse()); + if ((crop != mCurrentCrop) || (transform != mCurrentTransform) || + (scalingMode != mCurrentScalingMode) || + (transformToDisplayInverse != mTransformToDisplayInverse)) { mCurrentCrop = crop; mCurrentTransform = transform; mCurrentScalingMode = scalingMode; + mTransformToDisplayInverse = transformToDisplayInverse; recomputeVisibleRegions = true; } if (oldBuffer != nullptr) { - uint32_t bufWidth = getBE().compositionInfo.mBuffer->getWidth(); - uint32_t bufHeight = getBE().compositionInfo.mBuffer->getHeight(); - if (bufWidth != uint32_t(oldBuffer->width) || - bufHeight != uint32_t(oldBuffer->height)) { + uint32_t bufWidth = mActiveBuffer->getWidth(); + uint32_t bufHeight = mActiveBuffer->getHeight(); + if (bufWidth != uint32_t(oldBuffer->width) || bufHeight != uint32_t(oldBuffer->height)) { recomputeVisibleRegions = true; } } - mCurrentOpacity = getOpacityForFormat(getBE().compositionInfo.mBuffer->format); if (oldOpacity != isOpaque(s)) { recomputeVisibleRegions = true; } @@ -595,6 +526,9 @@ Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime } if ((*point)->getFrameNumber() <= mCurrentFrameNumber) { + std::stringstream ss; + ss << "Dropping sync point " << (*point)->getFrameNumber(); + ATRACE_NAME(ss.str().c_str()); point = mLocalSyncPoints.erase(point); } else { ++point; @@ -602,204 +536,85 @@ Region BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime } } - // FIXME: postedRegion should be dirty & bounds - Region dirtyRegion(Rect(s.active.w, s.active.h)); - - // transform the dirty region to window-manager space - outDirtyRegion = (getTransform().transform(dirtyRegion)); - - return outDirtyRegion; -} - -void BufferLayer::setDefaultBufferSize(uint32_t w, uint32_t h) { - mConsumer->setDefaultBufferSize(w, h); + return true; } -void BufferLayer::setPerFrameData(const sp<const DisplayDevice>& displayDevice) { - // Apply this display's projection's viewport to the visible region - // before giving it to the HWC HAL. - const Transform& tr = displayDevice->getTransform(); - const auto& viewport = displayDevice->getViewport(); - Region visible = tr.transform(visibleRegion.intersect(viewport)); - auto hwcId = displayDevice->getHwcDisplayId(); - if (!hasHwcLayer(hwcId)) { - return; - } - auto& hwcInfo = getBE().mHwcLayers[hwcId]; - auto& hwcLayer = hwcInfo.layer; - auto error = hwcLayer->setVisibleRegion(visible); - if (error != HWC2::Error::None) { - ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(), - to_string(error).c_str(), static_cast<int32_t>(error)); - visible.dump(LOG_TAG); - } - - error = hwcLayer->setSurfaceDamage(surfaceDamageRegion); - if (error != HWC2::Error::None) { - ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(), - to_string(error).c_str(), static_cast<int32_t>(error)); - surfaceDamageRegion.dump(LOG_TAG); - } - - // Sideband layers - if (getBE().compositionInfo.hwc.sidebandStream.get()) { - setCompositionType(hwcId, HWC2::Composition::Sideband); - ALOGV("[%s] Requesting Sideband composition", mName.string()); - error = hwcLayer->setSidebandStream(getBE().compositionInfo.hwc.sidebandStream->handle()); - if (error != HWC2::Error::None) { - ALOGE("[%s] Failed to set sideband stream %p: %s (%d)", mName.string(), - getBE().compositionInfo.hwc.sidebandStream->handle(), to_string(error).c_str(), - static_cast<int32_t>(error)); +// transaction +void BufferLayer::notifyAvailableFrames() { + const auto headFrameNumber = getHeadFrameNumber(); + const bool headFenceSignaled = fenceHasSignaled(); + const bool presentTimeIsCurrent = framePresentTimeIsCurrent(); + Mutex::Autolock lock(mLocalSyncPointMutex); + for (auto& point : mLocalSyncPoints) { + if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled && + presentTimeIsCurrent) { + point->setFrameAvailable(); + sp<Layer> requestedSyncLayer = point->getRequestedSyncLayer(); + if (requestedSyncLayer) { + // Need to update the transaction flag to ensure the layer's pending transaction + // gets applied. + requestedSyncLayer->setTransactionFlags(eTransactionNeeded); + } } - return; - } - - // Device or Cursor layers - if (mPotentialCursor) { - ALOGV("[%s] Requesting Cursor composition", mName.string()); - setCompositionType(hwcId, HWC2::Composition::Cursor); - } else { - ALOGV("[%s] Requesting Device composition", mName.string()); - setCompositionType(hwcId, HWC2::Composition::Device); - } - - ALOGV("setPerFrameData: dataspace = %d", mCurrentDataSpace); - error = hwcLayer->setDataspace(mCurrentDataSpace); - if (error != HWC2::Error::None) { - ALOGE("[%s] Failed to set dataspace %d: %s (%d)", mName.string(), mCurrentDataSpace, - to_string(error).c_str(), static_cast<int32_t>(error)); - } - - const HdrMetadata& metadata = mConsumer->getCurrentHdrMetadata(); - error = hwcLayer->setPerFrameMetadata(displayDevice->getSupportedPerFrameMetadata(), metadata); - if (error != HWC2::Error::None && error != HWC2::Error::Unsupported) { - ALOGE("[%s] Failed to set hdrMetadata: %s (%d)", mName.string(), - to_string(error).c_str(), static_cast<int32_t>(error)); - } - - uint32_t hwcSlot = 0; - sp<GraphicBuffer> hwcBuffer; - hwcInfo.bufferCache.getHwcBuffer(getBE().compositionInfo.mBufferSlot, - getBE().compositionInfo.mBuffer, &hwcSlot, &hwcBuffer); - - auto acquireFence = mConsumer->getCurrentFence(); - error = hwcLayer->setBuffer(hwcSlot, hwcBuffer, acquireFence); - if (error != HWC2::Error::None) { - ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(), - getBE().compositionInfo.mBuffer->handle, to_string(error).c_str(), - static_cast<int32_t>(error)); } } -bool BufferLayer::isOpaque(const Layer::State& s) const { - // if we don't have a buffer or sidebandStream yet, we're translucent regardless of the - // layer's opaque flag. - if ((getBE().compositionInfo.hwc.sidebandStream == nullptr) && (getBE().compositionInfo.mBuffer == nullptr)) { - return false; - } - - // if the layer has the opaque flag, then we're always opaque, - // otherwise we use the current buffer's format. - return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity; +bool BufferLayer::hasReadyFrame() const { + return hasFrameUpdate() || getSidebandStreamChanged() || getAutoRefresh(); } -void BufferLayer::onFirstRef() { - Layer::onFirstRef(); - - // Creates a custom BufferQueue for SurfaceFlingerConsumer to use - sp<IGraphicBufferProducer> producer; - sp<IGraphicBufferConsumer> consumer; - BufferQueue::createBufferQueue(&producer, &consumer, true); - mProducer = new MonitoredProducer(producer, mFlinger, this); - { - // Grab the SF state lock during this since it's the only safe way to access RenderEngine - Mutex::Autolock lock(mFlinger->mStateLock); - mConsumer = new BufferLayerConsumer(consumer, mFlinger->getRenderEngine(), mTextureName, - this); - } - mConsumer->setConsumerUsageBits(getEffectiveUsage(0)); - mConsumer->setContentsChangedListener(this); - mConsumer->setName(mName); - - if (mFlinger->isLayerTripleBufferingDisabled()) { - mProducer->setMaxDequeuedBufferCount(2); +uint32_t BufferLayer::getEffectiveScalingMode() const { + if (mOverrideScalingMode >= 0) { + return mOverrideScalingMode; } - const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice()); - updateTransformHint(hw); + return mCurrentScalingMode; } -// --------------------------------------------------------------------------- -// Interface implementation for SurfaceFlingerConsumer::ContentsChangedListener -// --------------------------------------------------------------------------- - -void BufferLayer::onFrameAvailable(const BufferItem& item) { - // Add this buffer from our internal queue tracker - { // Autolock scope - Mutex::Autolock lock(mQueueItemLock); - mFlinger->mInterceptor->saveBufferUpdate(this, item.mGraphicBuffer->getWidth(), - item.mGraphicBuffer->getHeight(), - item.mFrameNumber); - // Reset the frame number tracker when we receive the first buffer after - // a frame number reset - if (item.mFrameNumber == 1) { - mLastFrameNumberReceived = 0; - } - - // Ensure that callbacks are handled in order - while (item.mFrameNumber != mLastFrameNumberReceived + 1) { - status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, - ms2ns(500)); - if (result != NO_ERROR) { - ALOGE("[%s] Timed out waiting on callback", mName.string()); - } - } - - mQueueItems.push_back(item); - android_atomic_inc(&mQueuedFrames); +bool BufferLayer::isProtected() const { + const sp<GraphicBuffer>& buffer(mActiveBuffer); + return (buffer != 0) && (buffer->getUsage() & GRALLOC_USAGE_PROTECTED); +} - // Wake up any pending callbacks - mLastFrameNumberReceived = item.mFrameNumber; - mQueueItemCondition.broadcast(); +bool BufferLayer::latchUnsignaledBuffers() { + static bool propertyLoaded = false; + static bool latch = false; + static std::mutex mutex; + std::lock_guard<std::mutex> lock(mutex); + if (!propertyLoaded) { + char value[PROPERTY_VALUE_MAX] = {}; + property_get("debug.sf.latch_unsignaled", value, "0"); + latch = atoi(value); + propertyLoaded = true; } - - mFlinger->signalLayerUpdate(); + return latch; } -void BufferLayer::onFrameReplaced(const BufferItem& item) { - { // Autolock scope - Mutex::Autolock lock(mQueueItemLock); +// h/w composer set-up +bool BufferLayer::allTransactionsSignaled() { + auto headFrameNumber = getHeadFrameNumber(); + bool matchingFramesFound = false; + bool allTransactionsApplied = true; + Mutex::Autolock lock(mLocalSyncPointMutex); - // Ensure that callbacks are handled in order - while (item.mFrameNumber != mLastFrameNumberReceived + 1) { - status_t result = mQueueItemCondition.waitRelative(mQueueItemLock, - ms2ns(500)); - if (result != NO_ERROR) { - ALOGE("[%s] Timed out waiting on callback", mName.string()); - } + for (auto& point : mLocalSyncPoints) { + if (point->getFrameNumber() > headFrameNumber) { + break; } + matchingFramesFound = true; - if (mQueueItems.empty()) { - ALOGE("Can't replace a frame on an empty queue"); - return; + if (!point->frameIsAvailable()) { + // We haven't notified the remote layer that the frame for + // this point is available yet. Notify it now, and then + // abort this attempt to latch. + point->setFrameAvailable(); + allTransactionsApplied = false; + break; } - mQueueItems.editItemAt(mQueueItems.size() - 1) = item; - // Wake up any pending callbacks - mLastFrameNumberReceived = item.mFrameNumber; - mQueueItemCondition.broadcast(); - } -} - -void BufferLayer::onSidebandStreamChanged() { - if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) { - // mSidebandStreamChanged was false - mFlinger->signalLayerUpdate(); + allTransactionsApplied = allTransactionsApplied && point->transactionIsApplied(); } -} - -bool BufferLayer::needsFiltering(const RenderArea& renderArea) const { - return mNeedsFiltering || renderArea.needsFiltering(); + return !matchingFramesFound || allTransactionsApplied; } // As documented in libhardware header, formats in the range @@ -824,184 +639,97 @@ bool BufferLayer::getOpacityForFormat(uint32_t format) { return true; } -bool BufferLayer::isHdrY410() const { - // pixel format is HDR Y410 masquerading as RGBA_1010102 - return (mCurrentDataSpace == ui::Dataspace::BT2020_ITU_PQ && - mConsumer->getCurrentApi() == NATIVE_WINDOW_API_MEDIA && - getBE().compositionInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102); -} - -void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const { - ATRACE_CALL(); - const State& s(getDrawingState()); - - computeGeometry(renderArea, getBE().mMesh, useIdentityTransform); - - /* - * NOTE: the way we compute the texture coordinates here produces - * different results than when we take the HWC path -- in the later case - * the "source crop" is rounded to texel boundaries. - * This can produce significantly different results when the texture - * is scaled by a large amount. - * - * The GL code below is more logical (imho), and the difference with - * HWC is due to a limitation of the HWC API to integers -- a question - * is suspend is whether we should ignore this problem or revert to - * GL composition when a buffer scaling is applied (maybe with some - * minimal value)? Or, we could make GL behave like HWC -- but this feel - * like more of a hack. - */ - const Rect bounds{computeBounds()}; // Rounds from FloatRect - - Transform t = getTransform(); - Rect win = bounds; - if (!s.finalCrop.isEmpty()) { - win = t.transform(win); - if (!win.intersect(s.finalCrop, &win)) { - win.clear(); - } - win = t.inverse().transform(win); - if (!win.intersect(bounds, &win)) { - win.clear(); - } - } - - float left = float(win.left) / float(s.active.w); - float top = float(win.top) / float(s.active.h); - float right = float(win.right) / float(s.active.w); - float bottom = float(win.bottom) / float(s.active.h); - - // TODO: we probably want to generate the texture coords with the mesh - // here we assume that we only have 4 vertices - Mesh::VertexArray<vec2> texCoords(getBE().mMesh.getTexCoordArray<vec2>()); - texCoords[0] = vec2(left, 1.0f - top); - texCoords[1] = vec2(left, 1.0f - bottom); - texCoords[2] = vec2(right, 1.0f - bottom); - texCoords[3] = vec2(right, 1.0f - top); - - auto& engine(mFlinger->getRenderEngine()); - engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), false /* disableTexture */, - getColor()); - engine.setSourceDataSpace(mCurrentDataSpace); - - if (isHdrY410()) { - engine.setSourceY410BT2020(true); +bool BufferLayer::needsFiltering(const sp<const DisplayDevice>& displayDevice) const { + // If we are not capturing based on the state of a known display device, we + // only return mNeedsFiltering + if (displayDevice == nullptr) { + return mNeedsFiltering; } - engine.drawMesh(getBE().mMesh); - engine.disableBlending(); - - engine.setSourceY410BT2020(false); -} - -uint32_t BufferLayer::getProducerStickyTransform() const { - int producerStickyTransform = 0; - int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform); - if (ret != OK) { - ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__, - strerror(-ret), ret); - return 0; + const auto outputLayer = findOutputLayerForDisplay(displayDevice); + if (outputLayer == nullptr) { + return mNeedsFiltering; } - return static_cast<uint32_t>(producerStickyTransform); -} -bool BufferLayer::latchUnsignaledBuffers() { - static bool propertyLoaded = false; - static bool latch = false; - static std::mutex mutex; - std::lock_guard<std::mutex> lock(mutex); - if (!propertyLoaded) { - char value[PROPERTY_VALUE_MAX] = {}; - property_get("debug.sf.latch_unsignaled", value, "0"); - latch = atoi(value); - propertyLoaded = true; - } - return latch; + const auto& compositionState = outputLayer->getState(); + const auto displayFrame = compositionState.displayFrame; + const auto sourceCrop = compositionState.sourceCrop; + return mNeedsFiltering || sourceCrop.getHeight() != displayFrame.getHeight() || + sourceCrop.getWidth() != displayFrame.getWidth(); } uint64_t BufferLayer::getHeadFrameNumber() const { - Mutex::Autolock lock(mQueueItemLock); - if (!mQueueItems.empty()) { - return mQueueItems[0].mFrameNumber; + if (hasFrameUpdate()) { + return getFrameNumber(); } else { return mCurrentFrameNumber; } } -bool BufferLayer::headFenceHasSignaled() const { - if (latchUnsignaledBuffers()) { - return true; +Rect BufferLayer::getBufferSize(const State& s) const { + // If we have a sideband stream, or we are scaling the buffer then return the layer size since + // we cannot determine the buffer size. + if ((s.sidebandStream != nullptr) || + (getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE)) { + return Rect(getActiveWidth(s), getActiveHeight(s)); } - Mutex::Autolock lock(mQueueItemLock); - if (mQueueItems.empty()) { - return true; + if (mActiveBuffer == nullptr) { + return Rect::INVALID_RECT; } - if (mQueueItems[0].mIsDroppable) { - // Even though this buffer's fence may not have signaled yet, it could - // be replaced by another buffer before it has a chance to, which means - // that it's possible to get into a situation where a buffer is never - // able to be latched. To avoid this, grab this buffer anyway. - return true; - } - return mQueueItems[0].mFenceTime->getSignalTime() != - Fence::SIGNAL_TIME_PENDING; -} -uint32_t BufferLayer::getEffectiveScalingMode() const { - if (mOverrideScalingMode >= 0) { - return mOverrideScalingMode; - } - return mCurrentScalingMode; -} + uint32_t bufWidth = mActiveBuffer->getWidth(); + uint32_t bufHeight = mActiveBuffer->getHeight(); -// ---------------------------------------------------------------------------- -// transaction -// ---------------------------------------------------------------------------- + // Undo any transformations on the buffer and return the result. + if (mCurrentTransform & ui::Transform::ROT_90) { + std::swap(bufWidth, bufHeight); + } -void BufferLayer::notifyAvailableFrames() { - auto headFrameNumber = getHeadFrameNumber(); - bool headFenceSignaled = headFenceHasSignaled(); - Mutex::Autolock lock(mLocalSyncPointMutex); - for (auto& point : mLocalSyncPoints) { - if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) { - point->setFrameAvailable(); + if (getTransformToDisplayInverse()) { + uint32_t invTransform = DisplayDevice::getPrimaryDisplayOrientationTransform(); + if (invTransform & ui::Transform::ROT_90) { + std::swap(bufWidth, bufHeight); } } + + return Rect(bufWidth, bufHeight); } -sp<IGraphicBufferProducer> BufferLayer::getProducer() const { - return mProducer; +std::shared_ptr<compositionengine::Layer> BufferLayer::getCompositionLayer() const { + return mCompositionLayer; } -// --------------------------------------------------------------------------- -// h/w composer set-up -// --------------------------------------------------------------------------- +FloatRect BufferLayer::computeSourceBounds(const FloatRect& parentBounds) const { + const State& s(getDrawingState()); -bool BufferLayer::allTransactionsSignaled() { - auto headFrameNumber = getHeadFrameNumber(); - bool matchingFramesFound = false; - bool allTransactionsApplied = true; - Mutex::Autolock lock(mLocalSyncPointMutex); + // If we have a sideband stream, or we are scaling the buffer then return the layer size since + // we cannot determine the buffer size. + if ((s.sidebandStream != nullptr) || + (getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE)) { + return FloatRect(0, 0, getActiveWidth(s), getActiveHeight(s)); + } - for (auto& point : mLocalSyncPoints) { - if (point->getFrameNumber() > headFrameNumber) { - break; - } - matchingFramesFound = true; + if (mActiveBuffer == nullptr) { + return parentBounds; + } - if (!point->frameIsAvailable()) { - // We haven't notified the remote layer that the frame for - // this point is available yet. Notify it now, and then - // abort this attempt to latch. - point->setFrameAvailable(); - allTransactionsApplied = false; - break; - } + uint32_t bufWidth = mActiveBuffer->getWidth(); + uint32_t bufHeight = mActiveBuffer->getHeight(); - allTransactionsApplied = allTransactionsApplied && point->transactionIsApplied(); + // Undo any transformations on the buffer and return the result. + if (mCurrentTransform & ui::Transform::ROT_90) { + std::swap(bufWidth, bufHeight); } - return !matchingFramesFound || allTransactionsApplied; + + if (getTransformToDisplayInverse()) { + uint32_t invTransform = DisplayDevice::getPrimaryDisplayOrientationTransform(); + if (invTransform & ui::Transform::ROT_90) { + std::swap(bufWidth, bufHeight); + } + } + + return FloatRect(0, 0, bufWidth, bufHeight); } } // namespace android |