Merge "Corrected drawingTransformMatrix" (860a055a) · Commits · e / os / android_frameworks_native

services/surfaceflinger/BufferLayer.cpp

+7 −2

Original line number	Original line	Diff line number	Diff line
	@@ -34,6 +34,7 @@
	#include <cutils/properties.h>		#include <cutils/properties.h>
	#include <gui/BufferItem.h>		#include <gui/BufferItem.h>
	#include <gui/BufferQueue.h>		#include <gui/BufferQueue.h>
			#include <gui/GLConsumer.h>
	#include <gui/LayerDebugInfo.h>		#include <gui/LayerDebugInfo.h>
	#include <gui/Surface.h>		#include <gui/Surface.h>
	#include <renderengine/RenderEngine.h>		#include <renderengine/RenderEngine.h>
	@@ -187,8 +188,7 @@ std::optional<renderengine::LayerSettings> BufferLayer::prepareClientComposition

	// Query the texture matrix given our current filtering mode.		// Query the texture matrix given our current filtering mode.
	float textureMatrix[16];		float textureMatrix[16];
	setFilteringEnabled(useFiltering);		getDrawingTransformMatrix(useFiltering, textureMatrix);
	memcpy(textureMatrix, mBufferInfo.mTransformMatrix, sizeof(mBufferInfo.mTransformMatrix));

	if (getTransformToDisplayInverse()) {		if (getTransformToDisplayInverse()) {
	/*		/*
	@@ -719,6 +719,11 @@ sp<GraphicBuffer> BufferLayer::getBuffer() const {
	return mBufferInfo.mBuffer;		return mBufferInfo.mBuffer;
	}		}

			void BufferLayer::getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]) {
			GLConsumer::computeTransformMatrix(outMatrix, mBufferInfo.mBuffer, mBufferInfo.mCrop,
			mBufferInfo.mTransform, filteringEnabled);
			}

	} // namespace android		} // namespace android

	#if defined(__gl_h_)		#if defined(__gl_h_)

services/surfaceflinger/BufferLayer.h

+5 −4

Original line number	Original line	Diff line number	Diff line
	@@ -127,6 +127,10 @@ private:

	PixelFormat getPixelFormat() const;		PixelFormat getPixelFormat() const;

			// Computes the transform matrix using the setFilteringEnabled to determine whether the
			// transform matrix should be computed for use with bilinear filtering.
			void getDrawingTransformMatrix(bool filteringEnabled, float outMatrix[16]);

	virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;		virtual uint64_t getFrameNumber(nsecs_t expectedPresentTime) const = 0;

	virtual bool getAutoRefresh() const = 0;		virtual bool getAutoRefresh() const = 0;
	@@ -137,8 +141,6 @@ private:

	virtual bool hasFrameUpdate() const = 0;		virtual bool hasFrameUpdate() const = 0;

	virtual void setFilteringEnabled(bool enabled) = 0;

	virtual status_t bindTextureImage() = 0;		virtual status_t bindTextureImage() = 0;
	virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,		virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
	nsecs_t expectedPresentTime) = 0;		nsecs_t expectedPresentTime) = 0;
	@@ -151,9 +153,8 @@ protected:
	nsecs_t mDesiredPresentTime;		nsecs_t mDesiredPresentTime;
	std::shared_ptr<FenceTime> mFenceTime;		std::shared_ptr<FenceTime> mFenceTime;
	sp<Fence> mFence;		sp<Fence> mFence;
	float mTransformMatrix[16];
	uint32_t mTransform{0};		uint32_t mTransform{0};
	ui::Dataspace mDataspace;		ui::Dataspace mDataspace{ui::Dataspace::UNKNOWN};
	Rect mCrop;		Rect mCrop;
	uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};		uint32_t mScaleMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
	Region mSurfaceDamage;		Region mSurfaceDamage;

services/surfaceflinger/BufferQueueLayer.cpp

+0 −12

Original line number	Original line	Diff line number	Diff line
	@@ -151,13 +151,6 @@ bool BufferQueueLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) co
	return mQueueItems[0].mTimestamp <= expectedPresentTime;		return mQueueItems[0].mTimestamp <= expectedPresentTime;
	}		}

	// NOTE: SurfaceFlinger's definitions of "Current" and "Drawing" do not neatly map to BufferQueue's
	// These functions get the fields for the frame that is currently in SurfaceFlinger's Drawing state
	// so the functions start with "getDrawing". The data is retrieved from the BufferQueueConsumer's
	// current buffer so the consumer functions start with "getCurrent".
	//
	// This results in the rather confusing functions below.

	uint64_t BufferQueueLayer::getFrameNumber(nsecs_t expectedPresentTime) const {		uint64_t BufferQueueLayer::getFrameNumber(nsecs_t expectedPresentTime) const {
	Mutex::Autolock lock(mQueueItemLock);		Mutex::Autolock lock(mQueueItemLock);
	uint64_t frameNumber = mQueueItems[0].mFrameNumber;		uint64_t frameNumber = mQueueItems[0].mFrameNumber;
	@@ -220,10 +213,6 @@ bool BufferQueueLayer::hasFrameUpdate() const {
	return mQueuedFrames > 0;		return mQueuedFrames > 0;
	}		}

	void BufferQueueLayer::setFilteringEnabled(bool enabled) {
	return mConsumer->setFilteringEnabled(enabled);
	}

	status_t BufferQueueLayer::bindTextureImage() {		status_t BufferQueueLayer::bindTextureImage() {
	return mConsumer->bindTextureImage();		return mConsumer->bindTextureImage();
	}		}
	@@ -532,7 +521,6 @@ void BufferQueueLayer::gatherBufferInfo() {
	mBufferInfo.mDesiredPresentTime = mConsumer->getTimestamp();		mBufferInfo.mDesiredPresentTime = mConsumer->getTimestamp();
	mBufferInfo.mFenceTime = mConsumer->getCurrentFenceTime();		mBufferInfo.mFenceTime = mConsumer->getCurrentFenceTime();
	mBufferInfo.mFence = mConsumer->getCurrentFence();		mBufferInfo.mFence = mConsumer->getCurrentFence();
	mConsumer->getTransformMatrix(mBufferInfo.mTransformMatrix);
	mBufferInfo.mTransform = mConsumer->getCurrentTransform();		mBufferInfo.mTransform = mConsumer->getCurrentTransform();
	mBufferInfo.mDataspace = translateDataspace(mConsumer->getCurrentDataSpace());		mBufferInfo.mDataspace = translateDataspace(mConsumer->getCurrentDataSpace());
	mBufferInfo.mCrop = mConsumer->getCurrentCrop();		mBufferInfo.mCrop = mConsumer->getCurrentCrop();

services/surfaceflinger/BufferQueueLayer.h

+0 −4

services/surfaceflinger/BufferStateLayer.cpp

+3 −11

Original line number	Original line	Diff line number	Diff line
	@@ -432,11 +432,6 @@ bool BufferStateLayer::hasFrameUpdate() const {
	return mCurrentStateModified && (c.buffer != nullptr \|\| c.bgColorLayer != nullptr);		return mCurrentStateModified && (c.buffer != nullptr \|\| c.bgColorLayer != nullptr);
	}		}

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

	status_t BufferStateLayer::bindTextureImage() {		status_t BufferStateLayer::bindTextureImage() {
	const State& s(getDrawingState());		const State& s(getDrawingState());
	auto& engine(mFlinger->getRenderEngine());		auto& engine(mFlinger->getRenderEngine());
	@@ -545,10 +540,8 @@ void BufferStateLayer::latchPerFrameState(
	return;		return;
	}		}

	const State& s(getDrawingState());		compositionState.buffer = mBufferInfo.mBuffer;
			compositionState.bufferSlot = mBufferInfo.mBufferSlot;
	compositionState.buffer = s.buffer;
	compositionState.bufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);
	compositionState.acquireFence = mBufferInfo.mFence;		compositionState.acquireFence = mBufferInfo.mFence;

	mFrameNumber++;		mFrameNumber++;
	@@ -641,8 +634,6 @@ void BufferStateLayer::gatherBufferInfo() {
	mBufferInfo.mDesiredPresentTime = s.desiredPresentTime;		mBufferInfo.mDesiredPresentTime = s.desiredPresentTime;
	mBufferInfo.mFenceTime = std::make_shared<FenceTime>(s.acquireFence);		mBufferInfo.mFenceTime = std::make_shared<FenceTime>(s.acquireFence);
	mBufferInfo.mFence = s.acquireFence;		mBufferInfo.mFence = s.acquireFence;
	std::copy(std::begin(mTransformMatrix), std::end(mTransformMatrix),
	mBufferInfo.mTransformMatrix);
	mBufferInfo.mTransform = s.transform;		mBufferInfo.mTransform = s.transform;
	mBufferInfo.mDataspace = translateDataspace(s.dataspace);		mBufferInfo.mDataspace = translateDataspace(s.dataspace);
	mBufferInfo.mCrop = computeCrop(s);		mBufferInfo.mCrop = computeCrop(s);
	@@ -653,6 +644,7 @@ void BufferStateLayer::gatherBufferInfo() {
	mBufferInfo.mPixelFormat =		mBufferInfo.mPixelFormat =
	!mBufferInfo.mBuffer ? PIXEL_FORMAT_NONE : mBufferInfo.mBuffer->format;		!mBufferInfo.mBuffer ? PIXEL_FORMAT_NONE : mBufferInfo.mBuffer->format;
	mBufferInfo.mTransformToDisplayInverse = s.transformToDisplayInverse;		mBufferInfo.mTransformToDisplayInverse = s.transformToDisplayInverse;
			mBufferInfo.mBufferSlot = mHwcSlotGenerator->getHwcCacheSlot(s.clientCacheId);
	}		}

	Rect BufferStateLayer::computeCrop(const State& s) {		Rect BufferStateLayer::computeCrop(const State& s) {