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

services/surfaceflinger/BufferLayer.cpp

+7 −2

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

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

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

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

		} // namespace android

		#if defined(__gl_h_)

services/surfaceflinger/BufferLayer.h

+5 −4

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

		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 bool getAutoRefresh() const = 0;
		@@ -137,8 +141,6 @@ private:

		virtual bool hasFrameUpdate() const = 0;

		virtual void setFilteringEnabled(bool enabled) = 0;

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

services/surfaceflinger/BufferQueueLayer.cpp

+0 −12

Original line number	Diff line number	Diff line
		@@ -151,13 +151,6 @@ bool BufferQueueLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) co
		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 {
		Mutex::Autolock lock(mQueueItemLock);
		uint64_t frameNumber = mQueueItems[0].mFrameNumber;
		@@ -220,10 +213,6 @@ bool BufferQueueLayer::hasFrameUpdate() const {
		return mQueuedFrames > 0;
		}

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

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

services/surfaceflinger/BufferQueueLayer.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -46,7 +46,6 @@ public:

		std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;


		// If a buffer was replaced this frame, release the former buffer
		void releasePendingBuffer(nsecs_t dequeueReadyTime) override;

		@@ -65,7 +64,6 @@ public:
		bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;

		private:

		uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;

		bool getAutoRefresh() const override;
		@@ -75,8 +73,6 @@ private:

		bool hasFrameUpdate() const override;

		void setFilteringEnabled(bool enabled) override;

		status_t bindTextureImage() override;
		status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
		nsecs_t expectedPresentTime) override;

services/surfaceflinger/BufferStateLayer.cpp

+3 −11

Original line number	Diff line number	Diff line
		@@ -432,11 +432,6 @@ bool BufferStateLayer::hasFrameUpdate() const {
		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() {
		const State& s(getDrawingState());
		auto& engine(mFlinger->getRenderEngine());
		@@ -545,10 +540,8 @@ void BufferStateLayer::latchPerFrameState(
		return;
		}

		const State& s(getDrawingState());

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

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

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