Refactor surfacefinger Layer::latchBuffer (7b1563a0) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.mk

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -15,6 +15,7 @@ LOCAL_SRC_FILES := \
	GpuService.cpp \		GpuService.cpp \
	Layer.cpp \		Layer.cpp \
	LayerDim.cpp \		LayerDim.cpp \
			LayerRejecter.cpp \
	MessageQueue.cpp \		MessageQueue.cpp \
	MonitoredProducer.cpp \		MonitoredProducer.cpp \
	SurfaceFlingerConsumer.cpp \		SurfaceFlingerConsumer.cpp \

services/surfaceflinger/Layer.cpp

+4 −127

Original line number	Original line	Diff line number	Diff line
	@@ -44,6 +44,7 @@
	#include "Colorizer.h"		#include "Colorizer.h"
	#include "DisplayDevice.h"		#include "DisplayDevice.h"
	#include "Layer.h"		#include "Layer.h"
			#include "LayerRejecter.h"
	#include "MonitoredProducer.h"		#include "MonitoredProducer.h"
	#include "SurfaceFlinger.h"		#include "SurfaceFlinger.h"

	@@ -1829,133 +1830,6 @@ Region Layer::latchBuffer(bool& recomputeVisibleRegions)
	const bool oldOpacity = isOpaque(s);		const bool oldOpacity = isOpaque(s);
	sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer;		sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer;

	struct Reject : public SurfaceFlingerConsumer::BufferRejecter {
	Layer::State& front;
	Layer::State& current;
	bool& recomputeVisibleRegions;
	bool stickyTransformSet;
	const char* name;
	int32_t overrideScalingMode;
	bool& freezePositionUpdates;

	Reject(Layer::State& front, Layer::State& current,
	bool& recomputeVisibleRegions, bool stickySet,
	const char* name,
	int32_t overrideScalingMode,
	bool& freezePositionUpdates)
	: front(front), current(current),
	recomputeVisibleRegions(recomputeVisibleRegions),
	stickyTransformSet(stickySet),
	name(name),
	overrideScalingMode(overrideScalingMode),
	freezePositionUpdates(freezePositionUpdates) {
	}

	virtual bool reject(const sp<GraphicBuffer>& buf,
	const BufferItem& item) {
	if (buf == NULL) {
	return false;
	}

	uint32_t bufWidth = buf->getWidth();
	uint32_t bufHeight = buf->getHeight();

	// check that we received a buffer of the right size
	// (Take the buffer's orientation into account)
	if (item.mTransform & Transform::ROT_90) {
	swap(bufWidth, bufHeight);
	}

	int actualScalingMode = overrideScalingMode >= 0 ?
	overrideScalingMode : item.mScalingMode;
	bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
	if (front.active != front.requested) {

	if (isFixedSize \|\|
	(bufWidth == front.requested.w &&
	bufHeight == front.requested.h))
	{
	// Here we pretend the transaction happened by updating the
	// current and drawing states. Drawing state is only accessed
	// in this thread, no need to have it locked
	front.active = front.requested;

	// We also need to update the current state so that
	// we don't end-up overwriting the drawing state with
	// this stale current state during the next transaction
	//
	// NOTE: We don't need to hold the transaction lock here
	// because State::active is only accessed from this thread.
	current.active = front.active;
	current.modified = true;

	// recompute visible region
	recomputeVisibleRegions = true;
	}

	ALOGD_IF(DEBUG_RESIZE,
	"[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n"
	" drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
	" requested={ wh={%4u,%4u} }}\n",
	name,
	bufWidth, bufHeight, item.mTransform, item.mScalingMode,
	front.active.w, front.active.h,
	front.crop.left,
	front.crop.top,
	front.crop.right,
	front.crop.bottom,
	front.crop.getWidth(),
	front.crop.getHeight(),
	front.requested.w, front.requested.h);
	}

	if (!isFixedSize && !stickyTransformSet) {
	if (front.active.w != bufWidth \|\|
	front.active.h != bufHeight) {
	// reject this buffer
	ALOGE("[%s] rejecting buffer: "
	"bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}",
	name, bufWidth, bufHeight, front.active.w, front.active.h);
	return true;
	}
	}

	// if the transparent region has changed (this test is
	// conservative, but that's fine, worst case we're doing
	// a bit of extra work), we latch the new one and we
	// trigger a visible-region recompute.
	if (!front.activeTransparentRegion.isTriviallyEqual(
	front.requestedTransparentRegion)) {
	front.activeTransparentRegion = front.requestedTransparentRegion;

	// We also need to update the current state so that
	// we don't end-up overwriting the drawing state with
	// this stale current state during the next transaction
	//
	// NOTE: We don't need to hold the transaction lock here
	// because State::active is only accessed from this thread.
	current.activeTransparentRegion = front.activeTransparentRegion;

	// recompute visible region
	recomputeVisibleRegions = true;
	}

	if (front.crop != front.requestedCrop) {
	front.crop = front.requestedCrop;
	current.crop = front.requestedCrop;
	recomputeVisibleRegions = true;
	}
	freezePositionUpdates = false;

	return false;
	}
	};

	Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
	getProducerStickyTransform() != 0, mName.string(),
	mOverrideScalingMode, mFreezePositionUpdates);


	// Check all of our local sync points to ensure that all transactions		// Check all of our local sync points to ensure that all transactions
	// which need to have been applied prior to the frame which is about to		// which need to have been applied prior to the frame which is about to
	// be latched have signaled		// be latched have signaled
	@@ -1995,6 +1869,9 @@ Region Layer::latchBuffer(bool& recomputeVisibleRegions)
	// BufferItem's that weren't actually queued. This can happen in shared		// BufferItem's that weren't actually queued. This can happen in shared
	// buffer mode.		// buffer mode.
	bool queuedBuffer = false;		bool queuedBuffer = false;
			LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
			getProducerStickyTransform() != 0, mName.string(),
			mOverrideScalingMode, mFreezePositionUpdates);
	status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,		status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,
	mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,		mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,
	mLastFrameNumberReceived);		mLastFrameNumberReceived);

services/surfaceflinger/LayerRejecter.cpp

0 → 100644

+126 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2011 The Android Open Source Project
			*
			* Licensed under the Apache License, Version 2.0 (the "License");
			* you may not use this file except in compliance with the License.
			* You may obtain a copy of the License at
			*
			* http://www.apache.org/licenses/LICENSE-2.0
			*
			* Unless required by applicable law or agreed to in writing, software
			* distributed under the License is distributed on an "AS IS" BASIS,
			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			* See the License for the specific language governing permissions and
			* limitations under the License.
			*/

			#include "LayerRejecter.h"

			#include "clz.h"

			#define DEBUG_RESIZE 0

			namespace android {

			LayerRejecter::LayerRejecter(Layer::State& front,
			Layer::State& current,
			bool& recomputeVisibleRegions,
			bool stickySet,
			const char* name,
			int32_t overrideScalingMode,
			bool& freezePositionUpdates)
			: mFront(front),
			mCurrent(current),
			mRecomputeVisibleRegions(recomputeVisibleRegions),
			mStickyTransformSet(stickySet),
			mName(name),
			mOverrideScalingMode(overrideScalingMode),
			mFreezePositionUpdates(freezePositionUpdates) {}

			bool LayerRejecter::reject(const sp<GraphicBuffer>& buf, const BufferItem& item) {
			if (buf == NULL) {
			return false;
			}

			uint32_t bufWidth = buf->getWidth();
			uint32_t bufHeight = buf->getHeight();

			// check that we received a buffer of the right size
			// (Take the buffer's orientation into account)
			if (item.mTransform & Transform::ROT_90) {
			swap(bufWidth, bufHeight);
			}

			int actualScalingMode = mOverrideScalingMode >= 0 ? mOverrideScalingMode : item.mScalingMode;
			bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
			if (mFront.active != mFront.requested) {
			if (isFixedSize \|\| (bufWidth == mFront.requested.w && bufHeight == mFront.requested.h)) {
			// Here we pretend the transaction happened by updating the
			// current and drawing states. Drawing state is only accessed
			// in this thread, no need to have it locked
			mFront.active = mFront.requested;

			// We also need to update the current state so that
			// we don't end-up overwriting the drawing state with
			// this stale current state during the next transaction
			//
			// NOTE: We don't need to hold the transaction lock here
			// because State::active is only accessed from this thread.
			mCurrent.active = mFront.active;
			mCurrent.modified = true;

			// recompute visible region
			mRecomputeVisibleRegions = true;
			}

			ALOGD_IF(DEBUG_RESIZE,
			"[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n"
			" drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) "
			"}\n"
			" requested={ wh={%4u,%4u} }}\n",
			mName, bufWidth, bufHeight, item.mTransform, item.mScalingMode, mFront.active.w,
			mFront.active.h, mFront.crop.left, mFront.crop.top, mFront.crop.right,
			mFront.crop.bottom, mFront.crop.getWidth(), mFront.crop.getHeight(),
			mFront.requested.w, mFront.requested.h);
			}

			if (!isFixedSize && !mStickyTransformSet) {
			if (mFront.active.w != bufWidth \|\| mFront.active.h != bufHeight) {
			// reject this buffer
			ALOGE("[%s] rejecting buffer: "
			"bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}",
			mName, bufWidth, bufHeight, mFront.active.w, mFront.active.h);
			return true;
			}
			}

			// if the transparent region has changed (this test is
			// conservative, but that's fine, worst case we're doing
			// a bit of extra work), we latch the new one and we
			// trigger a visible-region recompute.
			if (!mFront.activeTransparentRegion.isTriviallyEqual(mFront.requestedTransparentRegion)) {
			mFront.activeTransparentRegion = mFront.requestedTransparentRegion;

			// We also need to update the current state so that
			// we don't end-up overwriting the drawing state with
			// this stale current state during the next transaction
			//
			// NOTE: We don't need to hold the transaction lock here
			// because State::active is only accessed from this thread.
			mCurrent.activeTransparentRegion = mFront.activeTransparentRegion;

			// recompute visible region
			mRecomputeVisibleRegions = true;
			}

			if (mFront.crop != mFront.requestedCrop) {
			mFront.crop = mFront.requestedCrop;
			mCurrent.crop = mFront.requestedCrop;
			mRecomputeVisibleRegions = true;
			}
			mFreezePositionUpdates = false;

			return false;
			}

			} // namespace android
			No newline at end of file

services/surfaceflinger/LayerRejecter.h

0 → 100644

+47 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2007 The Android Open Source Project
			*
			* Licensed under the Apache License, Version 2.0 (the "License");
			* you may not use this file except in compliance with the License.
			* You may obtain a copy of the License at
			*
			* http://www.apache.org/licenses/LICENSE-2.0
			*
			* Unless required by applicable law or agreed to in writing, software
			* distributed under the License is distributed on an "AS IS" BASIS,
			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			* See the License for the specific language governing permissions and
			* limitations under the License.
			*/

			#ifndef ANDROID_LAYER_REJECTER_H
			#define ANDROID_LAYER_REJECTER_H

			#include "Layer.h"
			#include "SurfaceFlingerConsumer.h"

			namespace android {
			class LayerRejecter : public SurfaceFlingerConsumer::BufferRejecter {
			public:
			LayerRejecter(Layer::State &front,
			Layer::State &current,
			bool &recomputeVisibleRegions,
			bool stickySet,
			const char *name,
			int32_t overrideScalingMode,
			bool &freezePositionUpdates);

			virtual bool reject(const sp<GraphicBuffer> &buf, const BufferItem &item);

			private:
			Layer::State &mFront;
			Layer::State &mCurrent;
			bool &mRecomputeVisibleRegions;
			bool mStickyTransformSet;
			const char *mName;
			int32_t mOverrideScalingMode;
			bool &mFreezePositionUpdates;
			};
			} // namespace android

			#endif // ANDROID_LAYER_REJECTER_H
			No newline at end of file