Merge "Refactor surfacefinger Layer::latchBuffer" (7fa1d593) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.mk

+1 −0

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

services/surfaceflinger/Layer.cpp

+4 −127

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

		@@ -1829,133 +1830,6 @@ Region Layer::latchBuffer(bool& recomputeVisibleRegions)
		const bool oldOpacity = isOpaque(s);
		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
		// which need to have been applied prior to the frame which is about to
		// 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
		// buffer mode.
		bool queuedBuffer = false;
		LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
		getProducerStickyTransform() != 0, mName.string(),
		mOverrideScalingMode, mFreezePositionUpdates);
		status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,
		mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,
		mLastFrameNumberReceived);

services/surfaceflinger/LayerRejecter.cpp

0 → 100644

+126 −0

Original line number	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	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