Merge "Moved info about activeBuffer into bufferInfo (2/2)" (1e0a03cf) · Commits · e / os / android_frameworks_native

services/surfaceflinger/BufferLayer.cpp

+28 −25

Original line number	Diff line number	Diff line
		@@ -92,7 +92,7 @@ void BufferLayer::useEmptyDamage() {
		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)) {
		if ((mSidebandStream == nullptr) && (mBufferInfo.mBuffer == nullptr)) {
		return false;
		}

		@@ -103,7 +103,7 @@ bool BufferLayer::isOpaque(const Layer::State& s) const {

		bool BufferLayer::isVisible() const {
		bool visible = !(isHiddenByPolicy()) && getAlpha() > 0.0f &&
		(mActiveBuffer != nullptr \|\| mSidebandStream != nullptr);
		(mBufferInfo.mBuffer != nullptr \|\| mSidebandStream != nullptr);
		mFlinger->mScheduler->setLayerVisibility(mSchedulerLayerHandle, visible);

		return visible;
		@@ -144,7 +144,7 @@ std::optional<renderengine::LayerSettings> BufferLayer::prepareClientComposition
		return result;
		}

		if (CC_UNLIKELY(mActiveBuffer == 0)) {
		if (CC_UNLIKELY(mBufferInfo.mBuffer == 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
		@@ -176,9 +176,9 @@ std::optional<renderengine::LayerSettings> BufferLayer::prepareClientComposition
		const State& s(getDrawingState());
		auto& layer = *result;
		if (!blackOutLayer) {
		layer.source.buffer.buffer = mActiveBuffer;
		layer.source.buffer.buffer = mBufferInfo.mBuffer;
		layer.source.buffer.isOpaque = isOpaque(s);
		layer.source.buffer.fence = mActiveBufferFence;
		layer.source.buffer.fence = mBufferInfo.mFence;
		layer.source.buffer.textureName = mTextureName;
		layer.source.buffer.usePremultipliedAlpha = getPremultipledAlpha();
		layer.source.buffer.isY410BT2020 = isHdrY410();
		@@ -257,7 +257,7 @@ bool BufferLayer::isHdrY410() const {
		// pixel format is HDR Y410 masquerading as RGBA_1010102
		return (mBufferInfo.mDataspace == ui::Dataspace::BT2020_ITU_PQ &&
		mBufferInfo.mApi == NATIVE_WINDOW_API_MEDIA &&
		mActiveBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);
		mBufferInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);
		}

		void BufferLayer::latchPerFrameState(
		@@ -277,7 +277,7 @@ void BufferLayer::latchPerFrameState(
		}

		bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) {
		if (mBufferLatched) {
		if (mBufferInfo.mBuffer != nullptr) {
		Mutex::Autolock lock(mFrameEventHistoryMutex);
		mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime);
		}
		@@ -371,7 +371,8 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
		// Capture the old state of the layer for comparisons later
		const State& s(getDrawingState());
		const bool oldOpacity = isOpaque(s);
		sp<GraphicBuffer> oldBuffer = mActiveBuffer;

		BufferInfo oldBufferInfo = mBufferInfo;

		if (!allTransactionsSignaled(expectedPresentTime)) {
		mFlinger->setTransactionFlags(eTraversalNeeded);
		@@ -388,19 +389,16 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
		return false;
		}

		mBufferLatched = true;

		err = updateFrameNumber(latchTime);
		if (err != NO_ERROR) {
		return false;
		}

		BufferInfo oldBufferInfo = mBufferInfo;
		gatherBufferInfo();

		mRefreshPending = true;
		mFrameLatencyNeeded = true;
		if (oldBuffer == nullptr) {
		if (oldBufferInfo.mBuffer == nullptr) {
		// the first time we receive a buffer, we need to trigger a
		// geometry invalidation.
		recomputeVisibleRegions = true;
		@@ -413,10 +411,11 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
		recomputeVisibleRegions = true;
		}

		if (oldBuffer != nullptr) {
		uint32_t bufWidth = mActiveBuffer->getWidth();
		uint32_t bufHeight = mActiveBuffer->getHeight();
		if (bufWidth != uint32_t(oldBuffer->width) \|\| bufHeight != uint32_t(oldBuffer->height)) {
		if (oldBufferInfo.mBuffer != nullptr) {
		uint32_t bufWidth = mBufferInfo.mBuffer->getWidth();
		uint32_t bufHeight = mBufferInfo.mBuffer->getHeight();
		if (bufWidth != uint32_t(oldBufferInfo.mBuffer->width) \|\|
		bufHeight != uint32_t(oldBufferInfo.mBuffer->height)) {
		recomputeVisibleRegions = true;
		}
		}
		@@ -485,7 +484,7 @@ uint32_t BufferLayer::getEffectiveScalingMode() const {
		}

		bool BufferLayer::isProtected() const {
		const sp<GraphicBuffer>& buffer(mActiveBuffer);
		const sp<GraphicBuffer>& buffer(mBufferInfo.mBuffer);
		return (buffer != 0) && (buffer->getUsage() & GRALLOC_USAGE_PROTECTED);
		}

		@@ -589,12 +588,12 @@ Rect BufferLayer::getBufferSize(const State& s) const {
		return Rect(getActiveWidth(s), getActiveHeight(s));
		}

		if (mActiveBuffer == nullptr) {
		if (mBufferInfo.mBuffer == nullptr) {
		return Rect::INVALID_RECT;
		}

		uint32_t bufWidth = mActiveBuffer->getWidth();
		uint32_t bufHeight = mActiveBuffer->getHeight();
		uint32_t bufWidth = mBufferInfo.mBuffer->getWidth();
		uint32_t bufHeight = mBufferInfo.mBuffer->getHeight();

		// Undo any transformations on the buffer and return the result.
		if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
		@@ -625,12 +624,12 @@ FloatRect BufferLayer::computeSourceBounds(const FloatRect& parentBounds) const
		return FloatRect(0, 0, getActiveWidth(s), getActiveHeight(s));
		}

		if (mActiveBuffer == nullptr) {
		if (mBufferInfo.mBuffer == nullptr) {
		return parentBounds;
		}

		uint32_t bufWidth = mActiveBuffer->getWidth();
		uint32_t bufHeight = mActiveBuffer->getHeight();
		uint32_t bufWidth = mBufferInfo.mBuffer->getWidth();
		uint32_t bufHeight = mBufferInfo.mBuffer->getHeight();

		// Undo any transformations on the buffer and return the result.
		if (mBufferInfo.mTransform & ui::Transform::ROT_90) {
		@@ -670,9 +669,9 @@ Rect BufferLayer::getBufferCrop() const {
		if (!mBufferInfo.mCrop.isEmpty()) {
		// if the buffer crop is defined, we use that
		return mBufferInfo.mCrop;
		} else if (mActiveBuffer != nullptr) {
		} else if (mBufferInfo.mBuffer != nullptr) {
		// otherwise we use the whole buffer
		return mActiveBuffer->getBounds();
		return mBufferInfo.mBuffer->getBounds();
		} else {
		// if we don't have a buffer yet, we use an empty/invalid crop
		return Rect();
		@@ -716,6 +715,10 @@ ui::Dataspace BufferLayer::translateDataspace(ui::Dataspace dataspace) {
		return updatedDataspace;
		}

		sp<GraphicBuffer> BufferLayer::getBuffer() const {
		return mBufferInfo.mBuffer;
		}

		} // namespace android

		#if defined(__gl_h_)

services/surfaceflinger/BufferLayer.h

+5 −3

Original line number	Diff line number	Diff line
		@@ -114,6 +114,8 @@ public:

		ui::Dataspace getDataSpace() const override;

		sp<GraphicBuffer> getBuffer() const override;

		// -----------------------------------------------------------------------

		// -----------------------------------------------------------------------
		@@ -159,6 +161,9 @@ protected:
		int mApi;
		PixelFormat mPixelFormat;
		bool mTransformToDisplayInverse{false};

		sp<GraphicBuffer> mBuffer;
		int mBufferSlot{BufferQueue::INVALID_BUFFER_SLOT};
		};

		BufferInfo mBufferInfo;
		@@ -195,9 +200,6 @@ private:

		uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;

		// main thread.
		bool mBufferLatched{false}; // TODO: Use mActiveBuffer?

		// BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame
		// and its parent layer is not bounded
		Rect getBufferSize(const State& s) const override;

services/surfaceflinger/BufferQueueLayer.cpp

+8 −6

Original line number	Diff line number	Diff line
		@@ -343,11 +343,12 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t
		status_t BufferQueueLayer::updateActiveBuffer() {
		// update the active buffer
		mPreviousBufferId = getCurrentBufferId();
		mActiveBuffer = mConsumer->getCurrentBuffer(&mActiveBufferSlot, &mActiveBufferFence);
		mBufferInfo.mBuffer =
		mConsumer->getCurrentBuffer(&mBufferInfo.mBufferSlot, &mBufferInfo.mFence);
		auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;
		layerCompositionState.buffer = mActiveBuffer;
		layerCompositionState.buffer = mBufferInfo.mBuffer;

		if (mActiveBuffer == nullptr) {
		if (mBufferInfo.mBuffer == nullptr) {
		// this can only happen if the very first buffer was rejected.
		return BAD_VALUE;
		}
		@@ -372,9 +373,10 @@ void BufferQueueLayer::latchPerFrameState(
		return;
		}

		compositionState.buffer = mActiveBuffer;
		compositionState.bufferSlot =
		(mActiveBufferSlot == BufferQueue::INVALID_BUFFER_SLOT) ? 0 : mActiveBufferSlot;
		compositionState.buffer = mBufferInfo.mBuffer;
		compositionState.bufferSlot = (mBufferInfo.mBufferSlot == BufferQueue::INVALID_BUFFER_SLOT)
		? 0
		: mBufferInfo.mBufferSlot;
		compositionState.acquireFence = mBufferInfo.mFence;
		}

services/surfaceflinger/BufferQueueLayer.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -127,7 +127,6 @@ private:
		std::atomic<uint64_t> mLastFrameNumberReceived{0};

		bool mAutoRefresh{false};
		int mActiveBufferSlot{BufferQueue::INVALID_BUFFER_SLOT};

		// thread-safe
		std::atomic<int32_t> mQueuedFrames{0};

services/surfaceflinger/BufferStateLayer.cpp

+10 −9

Original line number	Diff line number	Diff line
		@@ -53,12 +53,12 @@ BufferStateLayer::BufferStateLayer(const LayerCreationArgs& args)
		}

		BufferStateLayer::~BufferStateLayer() {
		if (mActiveBuffer != nullptr) {
		// Ensure that mActiveBuffer is uncached from RenderEngine here, as
		if (mBufferInfo.mBuffer != nullptr) {
		// Ensure that mBuffer is uncached from RenderEngine here, as
		// RenderEngine may have been using the buffer as an external texture
		// after the client uncached the buffer.
		auto& engine(mFlinger->getRenderEngine());
		engine.unbindExternalTextureBuffer(mActiveBuffer->getId());
		engine.unbindExternalTextureBuffer(mBufferInfo.mBuffer->getId());
		}
		}

		@@ -433,8 +433,8 @@ bool BufferStateLayer::hasFrameUpdate() const {
		}

		void BufferStateLayer::setFilteringEnabled(bool enabled) {
		GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mActiveBuffer, mBufferInfo.mCrop,
		mBufferInfo.mTransform, enabled);
		GLConsumer::computeTransformMatrix(mTransformMatrix.data(), mBufferInfo.mBuffer,
		mBufferInfo.mCrop, mBufferInfo.mTransform, enabled);
		}

		status_t BufferStateLayer::bindTextureImage() {
		@@ -523,10 +523,10 @@ status_t BufferStateLayer::updateActiveBuffer() {
		}

		mPreviousBufferId = getCurrentBufferId();
		mActiveBuffer = s.buffer;
		mActiveBufferFence = s.acquireFence;
		mBufferInfo.mBuffer = s.buffer;
		mBufferInfo.mFence = s.acquireFence;
		auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;
		layerCompositionState.buffer = mActiveBuffer;
		layerCompositionState.buffer = mBufferInfo.mBuffer;

		return NO_ERROR;
		}
		@@ -650,7 +650,8 @@ void BufferStateLayer::gatherBufferInfo() {
		mBufferInfo.mSurfaceDamage = s.surfaceDamageRegion;
		mBufferInfo.mHdrMetadata = s.hdrMetadata;
		mBufferInfo.mApi = s.api;
		mBufferInfo.mPixelFormat = !mActiveBuffer ? PIXEL_FORMAT_NONE : mActiveBuffer->format;
		mBufferInfo.mPixelFormat =
		!mBufferInfo.mBuffer ? PIXEL_FORMAT_NONE : mBufferInfo.mBuffer->format;
		mBufferInfo.mTransformToDisplayInverse = s.transformToDisplayInverse;
		}